{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f0c1714d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import gym\n",
    "import collections\n",
    "from tqdm import tqdm\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "from torch import nn\n",
    "\n",
    "import sys \n",
    "sys.path.append(\"..\") \n",
    "import rl_utils as rl_utils"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "1972bfb0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Replaybuffer:\n",
    "    ''' 经验回放池 '''\n",
    "    def __init__(self, capacity):\n",
    "        # 队列,先进先出\n",
    "        '''\n",
    "        构建一个固定长度的经验回放缓冲区（Replay Buffer）\n",
    "        collections.deque 是 Python 标准库 collections 模块中的一个类，它代表的是双端队列（double-ended queue）。双端队列可以在队列的两端高效地进行元素的添加和删除操作。\n",
    "        maxlen=capacity 是 deque 类的一个参数，其作用是指定队列的最大长度。一旦队列中的元素数量达到 capacity，再往队列里添加新元素时，队列头部的元素就会被自动移除，以此保证队列的长度始终不超过 capacity。\n",
    "        '''\n",
    "        self.buffer = collections.deque(maxlen=capacity)\n",
    "    \n",
    "    def add(self, state, action, reward, next_state, done):\n",
    "        # 将数据加入buffer\n",
    "        self.buffer.append((state, action, reward, next_state, done))\n",
    "    \n",
    "    def sample(self, batch_size):\n",
    "        # 从buffer中采样数据,数量为batch_size\n",
    "        transitions = random.sample(self.buffer, batch_size)\n",
    "        state, action, reward, next_state, done = zip(*transitions)\n",
    "        return torch.tensor(state), action, reward, torch.tensor(next_state), done\n",
    "    \n",
    "    def size(self):\n",
    "        # 目前buffer中数据的数量\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4f10168a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Qnet(nn.Module):\n",
    "    ''' 只有一层隐藏层的Q网络 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super().__init__()\n",
    "        self.fc1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, action_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "e966c690",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[0, 1, 2],\n",
      "        [3, 4, 5]])\n",
      "tensor([[1],\n",
      "        [5]])\n",
      "tensor([1, 5])\n"
     ]
    }
   ],
   "source": [
    "i = torch.tensor([1, 2])\n",
    "i1 = torch.tensor([[1], [2]])\n",
    "a = torch.arange(6).reshape(2,3)\n",
    "print(a)\n",
    "print(a.gather(1, i1))\n",
    "print(a[[0,1], i])\n",
    "# print(a[:, i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "7a38d5e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQN:\n",
    "    ''' DQN算法 '''\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma, epsilon, target_update, device):\n",
    "        self.action_dim = action_dim\n",
    "        self.q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "\n",
    "        # 目标网络\n",
    "        self.target_q_net = Qnet(state_dim, hidden_dim, self.action_dim).to(device)\n",
    "\n",
    "        # 使用Adam优化器\n",
    "        self.optimizer = torch.optim.Adam(self.q_net.parameters(), lr=learning_rate)\n",
    "        # 折扣因子\n",
    "        self.gamma = gamma\n",
    "        # e-贪婪策略\n",
    "        self.epsilon = epsilon\n",
    "        # 目标网络更新频率\n",
    "        self.target_update = target_update\n",
    "        # 计数器，记录更新次数\n",
    "        self.count = 0\n",
    "        self.device = device\n",
    "    \n",
    "    def take_action(self, state):\n",
    "        # e-贪婪策略采取的动作\n",
    "        if torch.rand(1).item() < self.epsilon:\n",
    "            action = torch.randint(0, self.action_dim, (1,)).item()\n",
    "        else:\n",
    "            # 将状态转换为张量并传入主网络，选取 Q 值最大的动作。\n",
    "            state = torch.tensor(state, dtype=torch.float).to(self.device)\n",
    "            action = self.q_net(state).argmax().item()\n",
    "        return action\n",
    "    \n",
    "    def update(self, transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions']).view(-1, 1).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'], dtype=torch.float).view(-1, 1).to(self.device)\n",
    "\n",
    "        # Q值\n",
    "        '''\n",
    "        gather是 PyTorch 里的一个张量操作方法，其作用是依据指定的索引从输入张量里收集元素。\n",
    "        它的语法是torch.gather(input, dim, index)。\n",
    "            input：为输入张量。\n",
    "            dim：是收集元素的维度。\n",
    "            index：是索引张量，用来指定要收集的元素的位置。\n",
    "        gather(1, actions)\n",
    "            dim=1意味着按列收集元素。\n",
    "            actions是一个索引张量，其元素指明了每一行要选取的列的索引。\n",
    "        '''\n",
    "        q_values = self.q_net(states).gather(1, actions)\n",
    "        '''        \n",
    "        self.q_net(states) \n",
    "        tensor([[-0.0038, -0.1856],\n",
    "                [ 0.0375, -0.2553]])\n",
    "        q_values \n",
    "        tensor([[-0.0038], \n",
    "                [ 0.0375]])\n",
    "        '''\n",
    "\n",
    "        # 下个状态的最大Q值\n",
    "        max_next_q_values = self.target_q_net(next_states).max(dim=1)[0].reshape(-1, 1)\n",
    "        '''        \n",
    "        self.target_q_net(next_states) \n",
    "        tensor([[ 0.4068, -0.5697],\n",
    "                [ 0.0511, -0.1651]])\n",
    "        max_next_q_values \n",
    "        tensor([[0.4068],\n",
    "                [0.0511]])\n",
    "        '''\n",
    "\n",
    "        # TD误差目标\n",
    "        q_targets = rewards + self.gamma * max_next_q_values * (1 - dones)\n",
    "        '''\n",
    "        q_targets \n",
    "        tensor([[1.2521],\n",
    "                [1.2829]])\n",
    "        '''\n",
    "        # 均方误差损失函数\n",
    "        dqn_loss = torch.mean(F.mse_loss(q_values, q_targets))\n",
    "        '''\n",
    "        dqn_loss \n",
    "        tensor(1.2504)\n",
    "        '''\n",
    "        \n",
    "        # PyTorch中默认梯度会累积,这里需要显式将梯度置为0\n",
    "        self.optimizer.zero_grad()\n",
    "        # 反向传播更新参数\n",
    "        dqn_loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        if self.count % self.target_update == 0:\n",
    "            # 更新目标函数\n",
    "            self.target_q_net.load_state_dict(self.q_net.state_dict())\n",
    "        self.count += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "4a8b9647",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0:  38%|███▊      | 19/50 [00:00<00:00, 662.73it/s, episode=20, return=9.400]"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 50/50 [00:00<00:00, 567.87it/s, episode=50, return=9.400]\n",
      "Iteration 1:   0%|          | 0/50 [00:00<?, ?it/s]/tmp/ipykernel_940/3727708869.py:33: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  states = torch.tensor(transition_dict['states'], dtype=torch.float).to(self.device)\n",
      "/tmp/ipykernel_940/3727708869.py:36: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.detach().clone() or sourceTensor.detach().clone().requires_grad_(True), rather than torch.tensor(sourceTensor).\n",
      "  next_states = torch.tensor(transition_dict['next_states'], dtype=torch.float).to(self.device)\n",
      "Iteration 1: 100%|██████████| 50/50 [00:01<00:00, 32.86it/s, episode=100, return=10.500]\n",
      "Iteration 2: 100%|██████████| 50/50 [00:05<00:00,  9.88it/s, episode=150, return=64.400]\n",
      "Iteration 3: 100%|██████████| 50/50 [00:25<00:00,  1.97it/s, episode=200, return=157.800]\n",
      "Iteration 4: 100%|██████████| 50/50 [00:26<00:00,  1.87it/s, episode=250, return=173.700]\n",
      "Iteration 5: 100%|██████████| 50/50 [00:42<00:00,  1.18it/s, episode=300, return=209.700]\n",
      "Iteration 6: 100%|██████████| 50/50 [00:52<00:00,  1.05s/it, episode=350, return=197.500]\n",
      "Iteration 7: 100%|██████████| 50/50 [00:50<00:00,  1.02s/it, episode=400, return=252.700]\n",
      "Iteration 8: 100%|██████████| 50/50 [01:14<00:00,  1.50s/it, episode=450, return=456.900]\n",
      "Iteration 9: 100%|██████████| 50/50 [01:04<00:00,  1.29s/it, episode=500, return=372.500]\n"
     ]
    }
   ],
   "source": [
    "lr = 2e-3\n",
    "num_episodes = 500\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "epsilon = 0.01\n",
    "target_update = 10\n",
    "buffer_size = 10000\n",
    "minimal_size = 500\n",
    "batch_size = 64\n",
    "device = 'cpu'\n",
    "\n",
    "env_name = 'CartPole-v1'\n",
    "env = gym.make(env_name)\n",
    "random.seed(0)\n",
    "# env.seed(0)\n",
    "torch.manual_seed(0)\n",
    "replay_buffer = Replaybuffer(buffer_size)\n",
    "state_dim = env.observation_space.shape[0]\n",
    "action_dim = env.action_space.n\n",
    "agent = DQN(state_dim, hidden_dim, action_dim, lr, gamma, epsilon, target_update, device)\n",
    "\n",
    "return_list = []\n",
    "for i in range(10):\n",
    "    with tqdm(total=int(num_episodes / 10), desc='Iteration %d' % i) as pbar:\n",
    "        for i_episode in range(int(num_episodes / 10)):\n",
    "            epsilon_return = 0\n",
    "            state, _ = env.reset()\n",
    "            # print(state)\n",
    "            done = False\n",
    "            while not done:\n",
    "                action = agent.take_action(state)\n",
    "                # print(state)\n",
    "                # print('动作：', action)\n",
    "                next_state, reward, terminated, truncated, info = env.step(action)\n",
    "                if terminated or truncated:\n",
    "                    done = True\n",
    "                replay_buffer.add(state, action, reward, next_state, done)\n",
    "                state = next_state\n",
    "                # print('奖励：', reward)\n",
    "                epsilon_return += reward\n",
    "                # 当buffer数据的数量超过一定值后,才进行Q网络训练\n",
    "                '''\n",
    "                为什么要等缓冲区数据数量超过一定值后才进行 Q 网络训练\n",
    "                    打破数据相关性：\n",
    "                       在强化学习中，智能体与环境交互产生的经验数据通常具有很强的相关性。如果在缓冲区数据量较少时就开始训练，网络可能会过度拟合这些相关的数据，\n",
    "                       导致训练不稳定。当缓冲区中有足够多的数据时，从缓冲区中随机采样可以打破数据之间的相关性，使网络学习到更泛化的策略。\n",
    "                    提高样本多样性：\n",
    "                        早期的经验数据可能比较单一，因为智能体还处于探索阶段。等待缓冲区数据量达到一定值后再训练，可以让缓冲区包含更多不同状态和动\n",
    "                        作下的经验数据，增加样本的多样性，有助于网络学习到更全面的策略。\n",
    "                    保证批量训练的有效性：\n",
    "                        批量训练是深度学习中常用的方法，它可以利用 GPU 的并行计算能力加速训练过程。当缓冲区中的数据量足够时，\n",
    "                        才能采样到足够数量的数据组成一个有效的批量，从而使批量训练更加稳定和高效。\n",
    "                '''\n",
    "                if replay_buffer.size() > minimal_size:\n",
    "                    b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(batch_size)\n",
    "                    # b_s, b_a, b_r, b_ns, b_d = replay_buffer.sample(2)\n",
    "                    transition_dict = {'states': b_s, 'actions': b_a, 'next_states':b_ns, 'rewards':b_r, 'dones':b_d}\n",
    "                    '''\n",
    "                    print(transition_dict)\n",
    "                    {'states': tensor([[-0.0041, -0.4170,  0.0390,  0.6417],\n",
    "                                       [-0.0212, -0.1730, -0.0225,  0.2952]]), \n",
    "                    'actions': (0, 0), \n",
    "                    'next_states': tensor([[-0.0125, -0.6126,  0.0518,  0.9464],\n",
    "                                            [-0.0247, -0.3678, -0.0166,  0.5807]]), \n",
    "                    'rewards': (1.0, 1.0), \n",
    "                    'dones': (False, False)}\n",
    "                    '''\n",
    "                    agent.update(transition_dict)\n",
    "            # print(epsilon_return)\n",
    "            return_list.append(epsilon_return)\n",
    "            if (i_episode + 1) % 10 == 0:\n",
    "                pbar.set_postfix({'episode': '%d' % (num_episodes / 10 * i + i_episode + 1),\n",
    "                                  'return': '%.3f' % torch.mean(torch.tensor(return_list[-10:], dtype=torch.float32)).item()})\n",
    "            pbar.update(1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "82219e66",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/mnt/d/Code/Python/RL-Learning/.venv/lib/python3.11/site-packages/gym/envs/classic_control/cartpole.py:211: UserWarning: \u001b[33mWARN: You are calling render method without specifying any render mode. You can specify the render_mode at initialization, e.g. gym(\"CartPole-v1\", render_mode=\"rgb_array\")\u001b[0m\n",
      "  gym.logger.warn(\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "epsilon_list = list(range(len(return_list)))\n",
    "plt.plot(epsilon_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'DQN on {env_name}')\n",
    "env.render()\n",
    "plt.show()\n",
    "# env.render()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "1dfc3c93",
   "metadata": {},
   "outputs": [],
   "source": [
    "env = gym.make('CartPole-v1', render_mode='human')\n",
    "import time\n",
    "\n",
    "observation, _ = env.reset()\n",
    "# print(observation)\n",
    "\n",
    "for _ in range(1000):\n",
    "    env.render()\n",
    "    action = agent.take_action(observation)\n",
    "    # action = env.action_space.sample()\n",
    "    observation, reward, terminated, truncated, info = env.step(action)\n",
    "    if terminated or truncated:  # 检查是否结束\n",
    "        env.reset()\n",
    "    time.sleep(0.01)\n",
    "env.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "67e8efc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAdzlJREFUeJzt3Xd4VFX6B/DvlMykTnolIfQSuqAQBUWIIGJHV13Wjei6PxVcFXWVVQErLq59Ed3VBcu6rriCXWkKIkW61EhPIL33qef3x8y9mUkyqdPz/TxPHjP33pl7ZgLm5T3veY9CCCFAREREFKCU3h4AERERkTsx2CEiIqKAxmCHiIiIAhqDHSIiIgpoDHaIiIgooDHYISIiooDGYIeIiIgCGoMdIiIiCmgMdoiIiCigMdghIvIRP/zwAxQKBX744QdvD4UooDDYIfJhK1euhEKhkL+Cg4ORkpKC6dOn47XXXkNNTY3T5/7000+47rrrkJiYCK1Wiz59+uCuu+5CXl5ei2sXL14MhUKBxMRE1NfXtzjfp08fXHnllS59b91lNpuxYsUKTJ48GTExMfJ7nDNnDnbt2uXSe23duhWLFy9GZWVli3N9+vRx+BklJCRg0qRJWL16tUvH4G7Lly/HjTfeiN69e0OhUOC2227z9pCIXIbBDpEfeOqpp/D+++9j+fLluPfeewEA999/P0aMGIFffvmlxfWvv/46Jk2ahAMHDuDee+/FG2+8gRtuuAEfffQRRo4cie3bt7d6n+LiYixfvtyt78UVGhoacOWVV+L222+HEAJ/+ctfsHz5cvz+97/Htm3bcMEFF+Ds2bMuu9/WrVvx5JNPthrsAMDo0aPx/vvv4/3338dDDz2E/Px8XH/99XjzzTddNgZ3++tf/4qNGzdi2LBhUKvV3h4OkWsJIvJZK1asEADEzp07W5zbsGGDCAkJEenp6aK+vl4+vmXLFqFUKsWkSZNEXV2dw3OOHz8uEhMTRUpKiqioqJCPL1q0SAAQo0ePFomJiQ6vJ4QQ6enpYubMma59c90wd+5cAUC8/PLLLc6ZTCbxwgsviLy8vG7fp7a2VgghxAsvvCAAiFOnTrW4prXPpqCgQISFhYlBgwZ16n7ff/+9ACC+//77rg65y06fPi0sFosQQoiwsDCRnZ3t8TEQuQszO0R+asqUKXjiiSdw5swZfPDBB/Lxp59+GgqFAu+++y5CQ0MdntO/f38sXboU+fn5+Mc//tHiNRcuXIiioqJuZXfeeOMNDBs2DFqtFikpKZg7d26LjMjkyZMxfPhwHD58GJdeeilCQ0PRq1cvLF26tN3XP3v2LN566y1cdtlluP/++1ucV6lUeOihh5CamgoAOHPmDO655x4MHjwYISEhiI2NxY033ojTp087PE+aMty0aRPuueceJCQkIDU1FYsXL8bDDz8MAOjbt688XdX8+faSkpIwdOhQnDp1Sj62d+9ezJgxAzqdDuHh4Zg6darTDFtzO3bswOWXX47IyEiEhobikksuwU8//dTmc4xGI2JiYjBnzpwW56qrqxEcHIyHHnpIPpaeng6FQtGh8RD5GwY7RH7s1ltvBQCsXbsWAFBfX48NGzZg0qRJ6Nu3b6vPuemmm6DVavHFF1+0ODdp0iRMmTIFS5cuRUNDQ6fHs3jxYsydOxcpKSl48cUXMWvWLLz11luYNm0ajEajw7UVFRW4/PLLMWrUKLz44osYMmQIHnnkEXzzzTdt3uObb76ByWSS33t7du7cia1bt+Lmm2/Ga6+9hrvuugsbNmzA5MmTW61Puueee3D48GEsXLgQjz76KK6//nrccsstAICXX35Znq6Kj493ek+j0Yi8vDzExsYCAA4dOoRJkyZh//79+POf/4wnnngCp06dwuTJk7Fjx442x79x40ZcfPHFqK6uxqJFi/Dcc8+hsrISU6ZMwc8//+z0eUFBQbjuuuuwZs0aGAwGh3Nr1qyBXq/HzTff3Oa9iQKGt1NLRORcW9NYksjISDFmzBghhBD79u0TAMR9993X5uuOHDlSxMTEyI+laaySkhKxadMmAUC89NJL8vmOTGMVFxcLjUYjpk2bJsxms3z873//uwAg/vWvf8nHLrnkEgFAvPfee/IxvV4vkpKSxKxZs9q8zwMPPCAAiL1797Z5naT5lJwQQmzbtq3F/aXPeuLEicJkMjlc39401rRp00RJSYkoKSkR+/fvFzfffLMAIO69914hhBDXXnut0Gg04sSJE/Lz8vPzRUREhLj44ovlY82nsSwWixg4cKCYPn26PMUkvae+ffuKyy67rM33/t133wkA4osvvnA4fsUVV4h+/fo5fR6nsSjQMLND5OfCw8PlVVnSfyMiItp8TkREhNOVXBdffDEuvfTSTmd31q9fD4PBgPvvvx9KZdP/Wu68807odDp89dVXLcb9u9/9Tn6s0WhwwQUX4OTJk23ep7q6Wn4PHRESEiJ/bzQaUVZWhgEDBiAqKgp79uxpcf2dd94JlUrVodeWrF27FvHx8YiPj8eoUaOwatUq3HrrrfjrX/8Ks9mMtWvX4tprr0W/fv3k5yQnJ+O3v/0ttmzZIr+n5vbt24djx47ht7/9LcrKylBaWorS0lLU1dVh6tSp2Lx5MywWi9NxTZkyBXFxcfjvf/8rH6uoqMC6detw0003deo9EvkzltwT+bna2lokJCQAaAoA2lqSLp2XntOaxYsX45JLLsGbb76JBx54oEPjOHPmDABg8ODBDsc1Gg369esnn5ekpqa2qBGJjo5udXWZPZ1OJ7+HjmhoaMCSJUuwYsUKnDt3DkII+VxVVVWL651N/7Vl/PjxeOaZZ6BQKBAaGoqhQ4ciKioKAFBYWIj6+voWnwsADB06FBaLBXl5eRg2bFiL88eOHQMAZGdnO713VVUVwsLCUF5e7nA8Pj4earUas2bNwocffgi9Xg+tVotPP/0URqORwQ71KAx2iPzY2bNnUVVVhQEDBgAABg4cCLVa3WbAoNfrkZOTgwsuuMDpNRdffDEmT56MpUuX4q677nL5uAE4zZ7YByOtGTJkCADgwIEDGD16dLv3uffee7FixQrcf//9yMzMRGRkJBQKBW6++eZWsyL2maCOiouLQ1ZWVqef1x5pfC+88ILT9xoeHo6ffvoJl156qcPxU6dOoU+fPrj55pvx1ltv4ZtvvsG1116Ljz/+GEOGDMGoUaNcPl4iX8Vgh8iPvf/++wCA6dOnAwBCQ0MxdepUrF+/HmfOnEF6enqL53z88cfQ6/W48cYb23ztxYsXY/LkyXjrrbc6NBbpXjk5OQ7TNQaDAadOnXJZMDBjxgyoVCp88MEHHSpS/uSTT5CdnY0XX3xRPtbY2Oi0Z05rurNKKT4+HqGhocjJyWlx7ujRo1AqlUhLS2v1uf379wdgzWa19fmNGjUK69atcziWlJQEwBq4Jicn47///S8mTpyIjRs34rHHHuvq2yHyS6zZIfJTGzduxNNPP42+ffti9uzZ8vHHH38cQgjcdtttLWpuTp06hT//+c9IS0trN1C45JJLMHnyZPz1r39FY2Nju+PJysqCRqPBa6+95pCdeeedd1BVVYWZM2d28h22Li0tDXfeeSfWrl2L119/vcV5i8WCF198UW4qqFKpWmSLXn/9dZjN5g7fMywsDAA6FSBJVCoVpk2bhs8++8xhuXpRURE+/PBDTJw4UZ6aa27s2LHo378//va3v6G2trbF+ZKSEgDW6b+srCyHr+DgYACAUqnEDTfcgC+++ALvv/8+TCYTp7Cox2Fmh8gPfPPNNzh69ChMJhOKioqwceNGrFu3Dunp6fj888/lX2wAMHHiRLz88su4//77MXLkSNx2221ITk7G0aNH8c9//hNKpRJr1qyRa0rasmjRohbTI87Ex8djwYIFePLJJ3H55Zfj6quvRk5ODt544w2cf/75DsXI3fXiiy/ixIkT+NOf/oRPP/0UV155JaKjo5Gbm4tVq1bh6NGj8rLqK6+8Eu+//z4iIyORkZGBbdu2Yf369fKy8I4YO3YsAOCxxx7DzTffjKCgIFx11VVyENSeZ555BuvWrcPEiRNxzz33QK1W46233oJer2+zt5BSqcTbb7+NGTNmYNiwYZgzZw569eqFc+fO4fvvv4dOp2u1hUBzN910E15//XUsWrQII0aMwNChQ1tc88UXX2D//v0ArIXcv/zyC5555hkAwNVXX42RI0d26L0S+SSvrgUjojZJy6GlL41GI5KSksRll10mXn31VVFdXe30uT/++KO45pprRFxcnFAoFAKASEhIEAUFBS2utV963py0TLyjHZT//ve/iyFDhoigoCCRmJgo7r77boduzdJrDhs2rMVzs7OzRXp6eofuYzKZxNtvvy0mTZokIiMjRVBQkEhPTxdz5sxxWJZeUVEh5syZI+Li4kR4eLiYPn26OHr0qEhPT3dYXt3eMv+nn35a9OrVSyiVSodl6B3tLr1nzx4xffp0ER4eLkJDQ8Wll14qtm7d6nCNsw7Ke/fuFddff72IjY0VWq1WpKeni9/85jdiw4YNHfqsLBaLSEtLEwDEM8880+o12dnZDn/W7L9WrFjRofsQ+SqFEO1UAxJRQHj66aexcOFCPPbYY/K/2ImIegJOYxH1EE888QTy8/Px7LPPonfv3vjjH//o7SEREXkEMztEREQU0Lgai4iIiAIagx0iIiIKaAx2iIiIKKAx2CEiIqKAxtVYsHZczc/PR0RERLfawhMREZHnCCFQU1ODlJQUKJXO8zcMdgDk5+c73ZuGiIiIfFteXh5SU1OdnmewAyAiIgKA9cNytkcNERER+Zbq6mqkpaXJv8edYbCDph2NdTodgx0iIiI/014JCguUiYiIKKAx2CEiIqKAxmCHiIiIAhqDHSIiIgpoDHaIiIgooDHYISIiooDGYIeIiIgCGoMdIiIiCmgMdoiIiCigMdghIiKigObVYGfx4sVQKBQOX0OGDJHPNzY2Yu7cuYiNjUV4eDhmzZqFoqIih9fIzc3FzJkzERoaioSEBDz88MMwmUyefitERETko7y+N9awYcOwfv16+bFa3TSkBx54AF999RVWrVqFyMhIzJs3D9dffz1++uknAIDZbMbMmTORlJSErVu3oqCgAL///e8RFBSE5557zuPvhYiIiHyP14MdtVqNpKSkFserqqrwzjvv4MMPP8SUKVMAACtWrMDQoUOxfft2TJgwAWvXrsXhw4exfv16JCYmYvTo0Xj66afxyCOPYPHixdBoNJ5+O0RERB5XXN0Ig9mC2DAtQjQqbw/HwdmKeigUCiREaBGk8s6Ektdrdo4dO4aUlBT069cPs2fPRm5uLgBg9+7dMBqNyMrKkq8dMmQIevfujW3btgEAtm3bhhEjRiAxMVG+Zvr06aiursahQ4ec3lOv16O6utrhi4iIyB+9uv4YLnhuAyb+9XtMWLIBlfUGbw/JwczXtuCi5zcit7zea2PwarAzfvx4rFy5Et9++y2WL1+OU6dOYdKkSaipqUFhYSE0Gg2ioqIcnpOYmIjCwkIAQGFhoUOgI52XzjmzZMkSREZGyl9paWmufWNEREQesutMufx9VYMRJ0rqvDialswWAQBQKxVeG4NXp7FmzJghfz9y5EiMHz8e6enp+PjjjxESEuK2+y5YsADz58+XH1dXVzPgISIiv1SnN7X52NtMFgsAQKnwXrDj9Wkse1FRURg0aBCOHz+OpKQkGAwGVFZWOlxTVFQk1/gkJSW1WJ0lPW6tDkii1Wqh0+kcvoiIiPxRvcHc7LFvBTtyZkfFYAcAUFtbixMnTiA5ORljx45FUFAQNmzYIJ/PyclBbm4uMjMzAQCZmZk4cOAAiouL5WvWrVsHnU6HjIwMj4+fiIjI0+pswU1kSBAAoFZvbutyj5OCHVVPncZ66KGHcNVVVyE9PR35+flYtGgRVCoVbrnlFkRGRuKOO+7A/PnzERMTA51Oh3vvvReZmZmYMGECAGDatGnIyMjArbfeiqVLl6KwsBCPP/445s6dC61W6823RkRE5BF1tuAmPkKLqgajT2V2LBYBW6wDtdJ7+RWvBjtnz57FLbfcgrKyMsTHx2PixInYvn074uPjAQAvv/wylEolZs2aBb1ej+nTp+ONN96Qn69SqfDll1/i7rvvRmZmJsLCwpCdnY2nnnrKW2+JiIjIo6QanfhwLY4X18rBjy8wCyF/32MzOx999FGb54ODg7Fs2TIsW7bM6TXp6en4+uuvXT00IiIin2cyW6A3WQuAE3TWGQ1fKlCWprAA767G8qmaHSIiIuq4Orvi5IQIW7DjQ9NYJotvZHYY7BAREfkpqT4nSKVAVKh114B6X5rGMjPYISIiom6Q6nNCNWqE2baJqHVjZkdvMmPX6XKYzJYOXS/12AEAFfvsEBERUWdJ9TnhWjVCtdYy3Ho31uws/vwQbnhzG/7+/fEOXS8VKCsVgJKZHSIiIuosqT4nVKNCuC3YqTO4bxrrPz/nAQBeWX+sQ9c3bRXh3XDD67ueExERUddI9TmhWjVCbdNYnlqN9af/7IVZCIxOjcKdF/dr9RqT2fsNBQEGO0RERH5LyuyEa1UIk6ax3JjZsff5/nwAwFe/FOCaMSlIiAhucY0vbAIKcBqLiIjIbzkWKFuDnVov9Nlx1shQWnqu8uK+WACDHSIiIr8lLT0P06gQprVOY7mrQNlgarkCS5qeau0cYLcvlhdXYgEMdoiIiPyWlFEJ06oRasvs1BvNsNg183OV8jqDw2OtWon4cGsjw3aDHdbsEBERUWdYLAI/nSjFgXNVAKzBjrQaSwhgxdbT0KgUUKuUuCwjEXHh3d8cu7RW7/A4VKOCRm3NmRjMrU9j+UrNDoMdIiIiP/PNwULM/XCP/DhCq0ZwkBIatRIGkwVPf3lYPrf9ZBlevXlMt+/ZPNjRqJVysKN3ktmRmgp6u2aHwQ4REZGf2ZNbAQDoFRWCYSk6XDumFxQKBZ69dji+zykGABRV67H7TAXOVjS45J7Hi2sdHmvVKmhUtsxOO9NY7LNDREREnfJrUQ0AYN6UAbjlgt7y8RvHpeHGcWkAgC3HSvG7d3agtrH7Bct7civwzFdHHI7ZZ3acBTsmH6nZYYEyERGRnzlWZM2yDEoMd3pNRLA1n1HTaOz2/Q6crWpx7MqRyXY1O769GouZHSIiIjf68VgJQjUqjE2PccnrVTUYUVjdCAAYkBDh9LqmYKf7mR2peeGNY1Mxf9og/HisFNeMTsHuM9bpNF/P7DDYISIicpPi6kbc+s7PAICTz13R7c0wq+qNOP/Z9QCAJF0wIkOCnF4bEWw9V2swwWIR3bp3vd0S9+TIEPzGNlXWXs2OtARezaaCREREgSmvol7+3hUZli8P5MtTRpcMim/zWimzI0RTZqar7DcctdfeNJavZHYY7BAREblJZX1TvUxFvaGNKzvmmwOFAIBbLuiN52eNaPNarVqJIFtGpbuBln1mx157Bcpm29Jzb/fZYbBDRETkJkXVTb1pyrsZ7FQ3GrHtZBkA4K5L+kHRTtGvQqGQp7K6G+w4zeyo2uuzw8wOERFRQCuyFRIDQGU3g52yWgPMFoFwrRrpsWEdeo7UVbm7K7KkndSlzUYl7Wd2fKPPDoMdIiIiNymuaQp2yuu6F3A0Gq0BR0iz7Epb5BVZ3dwctM72/FBtJ2t2zNZgp7uF2d3FYIeIiMhNCquagp2Kuu5ldhqkYCeoC8FOd2t2up3ZYbBDREQUkOxrdrpSoLwvrxJ//fYoGo1mNBq6EuxINTvdyyo5q9nRtrddhPCNmh322SEiInIT+2mszgQ7epMZa/aewyP/OwAAGJaik4Oc4M5MY2ldlNnp4mosEzM7REREgaveYEJpbVOAU9GJmp13t56WAx0AKK3R201jdfxXtzSN1d39sbraZ8dsO+7tzA6DHSIiIjdovkt4e0vP3992Gt8fte5YfrKkzuGcwWxBg5emsYQQTTU7zTM77UxjMbNDREQUwHIKaxwenyypxdx/78GWY6Utrt2fV4knPjuEOSt3Amg55VWnN3dpNVa4C1Zj6U0WudC4ZWZHJV/TGnkjUC49JyIiCjxSsHPRgFgAQGmtAV8dKMDv3tnR4trTZY6ZHGnKKzU6BIB16bc0jRWs7niwI2VipJqbrpCyOgAQ6mQ1lrHd7SK6fHuXYLBDRETkBjlF1mBn+rAkedsGZ/TGpmDBbBFyZqdXlC3YMZjRYLBe05kC5TDbtd3ZG0vqsaNVK1vU3rRXoGxhZoeIiChwSTU7w1J0GJgQ0ea1jaam7Emj0YyKeimzEwrAWuzclT47UibGPjvTWc7qdQC7mp12Mjus2SEiIgowJrNF3ioiLToUgxLD27y+wS4YqTeY5a0l7KexGrsQ7ITZOh7XdaNmx9lKLMCa7QHabyro7dVY7LNDRETkYiW1eliENaMRG66F1q7ORgoQ7FU2NK2WKqnRyxmRXnKwY25ajdWZaSxbNqar01jPf3MUm38tsb6WppXMjp/02WGwQ0RE5GIFtm0iEiK0UCkVyL6wD/67Kw+AdeWSwWSRAwUAqKw32j23AYA1gxMbpgHgOI0V3JnMjqZzBcrHi2uxZu85JEYGY/KgeLy56YR8Li0mtMX17fbZsdj67LRTs+RuDHaIiIhcrMgW7CRFBgMAMlJ0+PHPl2LS0u8BWPvexIZr5evtd0TPr7QGO9GhQXLNTa2+qzU7HS9QFkJg3od7cNS2iuzPlw8GAMRHaPHk1cNwYf/YFs/paJ8dlYI1O0RERAFFyuwkR4bIx9JiQhFum1aqbtbR2L6vTr7tuVGhGvn6eoN9n52O/+qWprEajU29cpzZfKxUDnQAYOepcgBA75hQXDEiGVGhmhbPkTI77fXZ8fY0FoMdIiIiFyu0FScn6oIdjutsTf6qGxw7GttPY6386TQAICZMg1C7AuPuFCgD7Wd3vv6lwOHx/rNVAKxTcc401ey0Pk3GpoJEREQBqlDO7DQLdkKs2zdUNzoPdqTpqrjwpsxOncEsLwHvTM2ORqWUsyrt1e1I2aVEnTW4Ka+zPm4z2Gln6bmc2fFyzQ6DHSIiIhcrbFazI5E25my+C3lrO6L/3yX95Zobs0WgypYN6kxmR6FQdLhup9a2PH1QomNPoIRm2Sl77S09N/nI0nMGO0RERC5WUqsH0DIrorNtzGk/jdVoNLeoeblpXBqGJusctmcos+2g3pml50DHt4yQgp0BCY49geI7MI1lEdbeQs2xZoeIiChAldZYg5245sFOK9NYta00/IsMtV6nUirkTE5Xlp4DHe+1U2vLNg1untnpQLADtD6VxcwOERFRAGo0muVdxuPCHAMFaRqryi6z09DKVg6RtqAIcCwyBjo3jQXY7Y/VThdlacwDWwQ7zqexNHY7fLY2lSX32WGwQ0REFDjKbIW9QSoFdCGO7eykaaxl35/AlmOlAFrftyoqtCnYab7TeGczO9Lz69rZH0vK7CREaBFn1wOoeZG1PbVKCSmOaS3YMZmZ2SEiIgo4ZbZ6ndgwLRTNmumN7xcjf//jces2DNL0lD37zM7gpKZMS1y41iEQ6ggpM1TfRmbHZLbI4wjXqrH0hhH4zbhU/HXWCESHteyvY6+tXjsW4Rs1O+ygTERE5EKltVK9TssgYdLAePzfJf3w1qaT8rRSfSu1NFEhTc/9+2/H4HB+NSwC6B8fhiBV5/IUYdr2Mzv2dUNhWjWmDEnElCGJHXp9jUqJRqOlnZod7+ZWGOwQERG5UGmNdRrLfirInlTHU2dbHdXYTmZHq1ZhTO/oLo8nVN4fy3lmR1oKr1UrHYqOO0KjVgEwOanZ8Y3MDqexiIiIXKi0rmkaqzXhzXrttFez013htmms1lZ9SaRzUgF1Z7TVa4c1O0RERAFIzuy0Mo0F2E0r2QKM1lZj6UJcGexYX6umjWDnXEWD7drOBztt7XzOzA4REVEAKrNldpovO5dImRap701rBcoRXQg6nHHWtVmy5Vgp/vDeLuvYupDZaWvnc5Nt6bmSwQ4REVHgkPaUinGyiknKtNS2MY3lyuBACmBqm+3HJXnjh+Py9xHazmeUNG1MYzGzQ0REFIDaq38Ja1ZD09o0livp2snspMeGyd9LS8U7o62l52bhGzU7XI1FRETkQlLGxln9S3jzmh3bNNbvM9ORX9mIKUMSXDoeOZPkpGYn1G6vrRMltZ1+/bZ2PpcKlNVcek5ERBQ4pKDCWf1LuF3fG4tFyJmdqFANnrpmuMvH017Njv02Ep3tzgx0bBrLy7EOp7GIiIhcqb3MTpjd8TqDSa7Z6eyeVx0lBV3VTmp27JsNvvSb0Z1+/aA2CpSNtmyPppONEF2NwQ4REZGLCCFQa2g7s6NVK+WC3Tq9GQ1G6/X200muJGV2avUmiFZqcqRmg3+dNQIX9I1pcb49TX12WtYeGW3TWJ3t+uxqDHaIiIhcpN5ghhRPOFvZpFAomlZI6Y3yNJa7MjvSOIRofcsIaQl88w1HO6qtPjtS0XJnuzK7GoMdIiIiF5HqdVRKBYKDnP+KDdNIwY65aRrLTZmd4KCmTFJtK3U70rYVXWkoCLTdZ0eaxmJmx+b555+HQqHA/fffLx9rbGzE3LlzERsbi/DwcMyaNQtFRUUOz8vNzcXMmTMRGhqKhIQEPPzwwzCZnHeJJCIicpcau3qd5jue27NfkSXtjeWuaSz7TFJNK3U7TZmdrt2/rQJl6ZiWmR1g586deOuttzBy5EiH4w888AC++OILrFq1Cps2bUJ+fj6uv/56+bzZbMbMmTNhMBiwdetWvPvuu1i5ciUWLlzo6bdARETUtBKrnSyJ/f5Y7i5QBuxWZLWy/LzeltkJ62pmR+qz08o0FjM7NrW1tZg9ezb++c9/Ijq6aVfXqqoqvPPOO3jppZcwZcoUjB07FitWrMDWrVuxfft2AMDatWtx+PBhfPDBBxg9ejRmzJiBp59+GsuWLYPBYPDWWyIioh5KmiZqb0NNKbB44L/7UFxj3V7CXdNYgN3+WK1NY7kps2OxCJhsS897fM3O3LlzMXPmTGRlZTkc3717N4xGo8PxIUOGoHfv3ti2bRsAYNu2bRgxYgQSExPla6ZPn47q6mocOnTI6T31ej2qq6sdvoiIiLqrVm+dJmovS9IrKgSAtaFgVYP1Oe4MdiKcTGMJIeQ+O13O7Dip2bEvWA5S9eAOyh999BH27NmDnTt3tjhXWFgIjUaDqKgoh+OJiYkoLCyUr7EPdKTz0jlnlixZgieffLKboyciInJU006PHckjlw+GLkSNtzadlI9FBLtup/PmpI1Fmxco600W2JIv3Z7GaivY8XZmx2vBTl5eHu677z6sW7cOwcHBHr33ggULMH/+fPlxdXU10tLSPDoGIiIKPO11T5ZEhWqwYMZQDEqIwDcHCzC8V6Sc7XEHZ12U7bsnd7VmSOtk6bnRLvgJ6qnbRezevRvFxcU477zz5GNmsxmbN2/G3//+d3z33XcwGAyorKx0yO4UFRUhKSkJAJCUlISff/7Z4XWl1VrSNa3RarXQarUufDdERER2NTsdzJLMGpuKWWNT3TkkAE1Zo+YFyvbF0V3drNNZZqepoaDCpbu4d4XXQq2pU6fiwIED2Ldvn/w1btw4zJ49W/4+KCgIGzZskJ+Tk5OD3NxcZGZmAgAyMzNx4MABFBcXy9esW7cOOp0OGRkZHn9PRETUs3V0NZanOVt6XivX63S9XshpzY7JN1ZiAV7M7ERERGD4cMcNz8LCwhAbGysfv+OOOzB//nzExMRAp9Ph3nvvRWZmJiZMmAAAmDZtGjIyMnDrrbdi6dKlKCwsxOOPP465c+cyc0NERB5X3di9Yl93kbeMaGye2ele92TAeQdl6bG363UAH9/1/OWXX4ZSqcSsWbOg1+sxffp0vPHGG/J5lUqFL7/8EnfffTcyMzMRFhaG7OxsPPXUU14cNRER9VTHimoAAGkxoV4eiSNpWq1lzU73euwAdn12mNnpmB9++MHhcXBwMJYtW4Zly5Y5fU56ejq+/vprN4+MiIiobQaTBb+cqwIAnNc7yruDaaapZsdxGksqUO5O92Zn01i+suM54AN9doiIiALBkYJqGEwWRIYEoW9cmLeH4yDcydLzGhfUGLW39NwXprG8PwIiIqIAsOtMBQBgTO+oNvfF8gZnS89rOtjxuS3OanakpefM7BAREQUAIQQ+2X0WADBxQJyXR9NSuJO9sZq2t+h6Q0Opz46xWbAj7ZUVpPZ+4Mdgh4iIqJt2n6nAkYJqBAcpcYMH+uZ0lk6q2Wm29Fx6rOtOZkdlrfc5U1aPvPJ6+bjRhwqUvT8CIiIiP7fjVDkAIGtoIqJCNV4eTUtSTU6j0eKQgeno9hZtvrZdoPTgx/vl7w0+VKDsU6uxiIiI/FFumTWjMTAhwssjaZ19QHLh8xsRGWLN9BwvrgXQvZqdPrGhyBqagPVHilFQ3SAfN7JAmYiIyP8dL65FYVUjzpTXAQDSY32rv44kSKWUMywlNXocL66VAx2gezU7CoUCD00fDABosG0/ATStzmJmh4iIyE+V1uqR9dImAJA38fS1ZoL27FdLffiH8fjt2zvkx93J7ABAaJD1+VKTQuv9pL2xvB/seH8EREREfuiEXWbkXKV1+sZXMzv2goOUuHBAHKJCm7I57e3S3p5Q295aDUYzLBZrkCNndjiNRURE5J/Mtl/qkjCNCrFhvlec3NzIXlEAgISIpj0kdd2YxgIcOzA3GK3ZHalmh5kdIiIiP1XV4LiMOy0m1OeaCdr705QBiAhWY8msEQCAhIhg+Vx3p7GC1SpIb33TryW48vUfsf1kGQDfyOywZoeIiKgLKpsFO/3ifWuLiObmTxuM+7MGQam0RiWx4U1ZqO4UKAOAUqlASJAK9QYz7vn3HodzGpX3A0Dvh1tERER+qLLeMdjpHx/upZF0nBToAI5TT93ps9P0eq2/hi9kdrw/AiIiIj/UfBprQILvBzv2goOagh1XBCTOdk5nzQ4REZGfqmowODz2h8yOvZCg1oOTrnIW7DCzQ0RE5KeaT2P5es1Oc2PTo136emFOpsJ8IbPDAmUiIqIuaB7sOKtZ8VVThiRg6ayRyEjRueT1nGV2tD6Q2fGvnwwREZGPkFZjTRoYh3mXDvDyaDpPoVDgN+enuez1fLlmh8EOERFRF1Tbgp2Hpg3GqLQo7w7GB3A1FhERUQC576O98hYR0g7iPR0zO0RERAHAYLIgt7wOn+3Ll49Fh/r+FhGe4DzY8X5TQQY7REREHSCEwP+9vwvf55TIx+6Z3B+RoczsAM6nsVzRsLC7vJ9bIiIi8gMbjhQ7BDpDkiLw58uHeHFEvsVZZkfnA9N8DHaIiIg6YPW+cw6P02NDvTQS3yTtct5cdzcZdQUGO0RERB2QbytIlvSJ9a8mgu7mrFC7u5uMuoL3wy0iIiI/UFjV6PA4ioXJDn5zfhqKa/SYOjQR1y77ST6u84HMjvdHQERE5OPMFoHiGr3DsT6cxnKgVavw4LTBEEI4HA/zgc7S3h8BERFRBxwvroUuRI2EiGCP37u0Vg+zRUClVGDlnPOxN7cS04cleXwc/kChcFxqrlRy6TkREVG7DpytwlV/34IRvSLxxb0TPX7/AtsUVmKEFpMGxmPSwHiPj4G6jgXKRETk817beAwAcOBcVYtpEk8orLIWJydFej6rRN3HYIeIiHyawWTBJrv+NnUGs8fHIGV2kiNDPH5v6j4GO0RE5NN+LaqBwa6HS3mtweNjOFthzewk6pjZ6Qxf2CoCYLBDREQ+7nBBtcPj8nrPBzu7z1QAAIb30nn83v7MFzYBBRjsEBGRjzuc3yzYqdM7udI96vQmHDxXBQAY3y/Wo/f2dwx2iIiIOuBIs8xOmYensfbmVsJkEegVFYJeUazZ6QwGO0RERB0gBTtDkiIAABUensbal2edwjq/T7RH7xsIfKXxIoMdIiLyWSazBdWNJgBARoq1XqaszrPBzomSOgDAwMQIj97Xn/37D+MxaWAcXvrNaG8PBQCbChIRkRfkltXjeEkNLh2c0KLjrr0GY9My81TbFFKFh4OdkyW1AID+8dz4s6MuGhCHiwbEeXsYMmZ2iIjI4x5ctQ+3r9yFVzcca/O6BltPHaUCSLL1uCn3YLAjhMBJW2anX3y4x+5LrsVgh4iIPG7naWsdzCvrj6G01vnqKimzExKkQkyYdZfxgma7j7tTSa0eNXoTlAog3UfqT6jzGOwQEZHHRYUGyd//YNcduTk52NGoMLyXDiqlAofyq7H9ZJnbxwhAzuqkRodCq1Z55J7kegx2iIjI4xrstnz4IafY6XX1hqZgJzU6FDefnwYAeG/babeOT3LO1jm5dwyzOv6MwQ4RUQ+lN5mx42QZLBbPbqxpMlugNzVt//DjsVKYnYyh0dA0jQU0NfWrqDO6eZRWtXrrSjBdCNfz+DMGO0REPdT7287gpn9sx0Of7PfofeuNjht5VjUY5QxKi2vlzI412AhWW39tNZo8sxmoFOyEaRjs+DMGO0REPdT7288AAD7dc85hWsnd6vXWe6mUCgxIsK5wOl1W1+q1TQXK1l9XWluGp9FoafV6V6uTgh0tgx1/xmCHiKiHGpMWJX+/9nChx+5bb7AGEKEaFfrEWnvXnGk32LEGOVJmR++hzI4U7IQz2PFrDHaIiHoo+7oZTy7nlqamwjRqeTuB02X1rV4rZZxCbdNIUmZH76HMTq0tC8XMjn9jsENE1EPV201deSp4AJqyJaFaFdLjOpbZCZYyO0Heyuxw2bk/Y7BDRNRD2dfpeKrgF2gKskI1KvS1TWM5y+zYXwtA7nXjsZodA2t2AgGDHSKiHqreaJK/92hmR67ZUcv9a85WNAU7QggU2qbVGu2aCgKez+zUskA5IDDYISLqobyd2QnTqBBp66TcaLTAYKsh+tvaHExYsgEf7siVxyhNY0mZHaNZOO3N40osUA4MDHaIiHqoBi/V7NTLNTtqhyBCyqIs+/4EAGDR5wdbTGNJmR3AM9mdOhYoBwQGO0REPZR9cz9PTQsBQJ1dZkelVMiBTHWDEfvyKuXrTBbRNI3VLLMDeKZup5YFygGBoSoRUQ9lvxrLUwW/n+w+ixe+ywHQtJw8XKtGvcGMt7ecxAfbc+VrhWjqySMFOyqlAkEqBYxm4fYATQjBpoIBgpkdIqIeyGwRco0M4LnMzkOrmramkDI64cHWQMI+0JE0NCtQBoBgD63I0pssMNnqghjs+DcGO0REPVBDs/2pPFmzI5ECiIg2AokG27ikzA4AaG11O41G9wZoUlYH4N5Y/o7BDhFRDyRND0k8ldlJjQ6Rv1cpFQCAiOAgp9c32G0tIZHqduw7QLuDVJwcEqSSx0r+yavBzvLlyzFy5EjodDrodDpkZmbim2++kc83NjZi7ty5iI2NRXh4OGbNmoWioiKH18jNzcXMmTMRGhqKhIQEPPzwwzCZTM1vRUREdhoNjoGCp2p2YsM08venSqxdk9ta1v1rUS0AIFjj+cwOe+wEDq8GO6mpqXj++eexe/du7Nq1C1OmTME111yDQ4cOAQAeeOABfPHFF1i1ahU2bdqE/Px8XH/99fLzzWYzZs6cCYPBgK1bt+Ldd9/FypUrsXDhQm+9JSIiv2DfUBDwXGbHfvps1thUAE01O23pZ9tWAmiq2XF7ZsfAlViBwqvh6lVXXeXw+Nlnn8Xy5cuxfft2pKam4p133sGHH36IKVOmAABWrFiBoUOHYvv27ZgwYQLWrl2Lw4cPY/369UhMTMTo0aPx9NNP45FHHsHixYuh0Whauy0RUY9nvxILcH/g0Py+r9w0Ghf0jQHQfsO+//5xAqJCm/5/zswOdZbP1OyYzWZ89NFHqKurQ2ZmJnbv3g2j0YisrCz5miFDhqB3797Ytm0bAGDbtm0YMWIEEhMT5WumT5+O6upqOTtEREQtSQ0FFbZSFHcHDs3vOzRZJx+LaCez0zc+zOGxxzI7DHYChtd/ggcOHEBmZiYaGxsRHh6O1atXIyMjA/v27YNGo0FUVJTD9YmJiSgsLAQAFBYWOgQ60nnpnDN6vR56vV5+XF1d7aJ3Q0TkH6SgIyZUg7I6g8czO/YFx+1ldmJCHbP0nl6Nxa0i/J/XMzuDBw/Gvn37sGPHDtx9993Izs7G4cOH3XrPJUuWIDIyUv5KS0tz6/2IiHyN1D05St6bygwh3LvXlMUi5JqdYLul5G2txgIAtcrxV5WnMju13CoiYHg92NFoNBgwYADGjh2LJUuWYNSoUXj11VeRlJQEg8GAyspKh+uLioqQlJQEAEhKSmqxOkt6LF3TmgULFqCqqkr+ysvLc+2bIiLycdKS7mhb1sQiIDfQcxf7zUYdMjttTGNp1S1/TUmZHb3HMjssUPZ3Xg92mrNYLNDr9Rg7diyCgoKwYcMG+VxOTg5yc3ORmZkJAMjMzMSBAwdQXFwsX7Nu3TrodDpkZGQ4vYdWq5WXu0tfREQ9iTSdZF/46+5pIfuiaPsmgW01FbTvnCzxeM0OGwr6Pa/+BBcsWIAZM2agd+/eqKmpwYcffogffvgB3333HSIjI3HHHXdg/vz5iImJgU6nw7333ovMzExMmDABADBt2jRkZGTg1ltvxdKlS1FYWIjHH38cc+fOhVar9eZbIyLyaUXV1rrFRF3T/yv1Jgsi3HhPqU4oOEgJpV2TvrYyO6FBLYMdrsaizvLqT7C4uBi///3vUVBQgMjISIwcORLfffcdLrvsMgDAyy+/DKVSiVmzZkGv12P69Ol444035OerVCp8+eWXuPvuu5GZmYmwsDBkZ2fjqaee8tZbIiLyC0cKrAszhibroFUroTdZPJbZCW2WKRmU6DzECm4tsxMk7Y3FAmXqGK/+BN955502zwcHB2PZsmVYtmyZ02vS09Px9ddfu3poREQBrbVgx93TQs13MJdEhgQhMiQIVQ3GFs9pfi3QVMfDAmXqKJ+r2SEiIvcqqdGjuEYPhQIYkhQhZ0rcvRloQyvLziUv/WZUq8+Zf9mgFsek8TYYPJPZCWOBst9jsENE1MNIWZ0+sWEI06qbamDcvGVEaz12JFOHJmLjg5c4HNv66BRMHZrY4toY2/5aZXUGN4yySdN2Eczs+LsuBTsNDQ2or6+XH585cwavvPIK1q5d67KBERGRexRWNwIA0mNDAditbnJzZkfq7dPaCisA6Bcf7vA4JSqk1esSIqxF1cU1jS4cXUssUA4cXQp2rrnmGrz33nsAgMrKSowfPx4vvvgirrnmGixfvtylAyQiIteqb7ak2lOZHam3T/MC5c5KiAgGABRX69u5sntYoBw4uhTs7NmzB5MmTQIAfPLJJ0hMTMSZM2fw3nvv4bXXXnPpAImIyLWkDIs0neSxzI6h7cxOR0nL5Utr9TC7sRFiHQuUA0aXgp36+npERFiXCq5duxbXX389lEolJkyYgDNnzrh0gERE5Fr1esdgRxdi3a6hot69NTByzU4rK6wkj88cCgC465L+Tq+JDddCqbB2fS6rdU92Rwgh1+ywQNn/dSnYGTBgANasWYO8vDx89913mDZtGgBr3xx2IyYi8m1y0GHLWKRGW2tjzlbUO32OK5TaApPWCpQld0zsi80PX4pHLh/s9BqVUoG4cKluxz3BTr3BDGmrME5j+b8uBTsLFy7EQw89hD59+mD8+PHy9g1r167FmDFjXDpAIiJyLanfjZRhkYKdvPIGt93z+5xirNx6GgAwKMl5E0GFQoHesaFQKBROrwGABNtUVlG1e4qUpXodpaL1Xj/kX7oUrt5www2YOHEiCgoKMGpUU2+EqVOn4rrrrnPZ4IiIyPWaZ3bSoq2rstyV2TGZLXjmy8MQArhhbCpuPr93t1/TWqRc7bbMTq1dEXd7gRf5vi7n5pKSklrsLH7BBRd0e0BERNS2Wr0Ju06X46IBcQhSdT5BL2d2NFJmxxrs5FW4J7Oz+VgJTpTUITo0CIuuyoBK2f3gIdHNmZ1GW7F2d4upyTd0Kdipq6vD888/jw0bNqC4uBgWi2MF/8mTJ10yOCIiaunuD3bjx2OleHzmUPxhUr9OP795c7+0GOs0VkmNHo1Gs9yh2FUKqqwBybg+MYgIDnLJayZHWsecX+meAE1vW4avUbP3biDoUrDzhz/8AZs2bcKtt96K5ORkpviIiDzox2OlAID/7TnXpWCnrtmGnJEhQQjXqlGrN+FsRQMGJIS39fROq26wZpJ0Lgp0APuiancFO9Z/xGsZ7ASELgU733zzDb766itcdNFFrh4PEREBOFpYjV+LanH1qBSH4/b7QfWLC+vSa0vN/cJsmR2FQoHU6BAcLaxBbnmd64OdRusGn7oQ161qSouR6ozcHexwGisQdOlPXnR0NGJiYlw9FiIisrn8lR8BAOFaFaYMadof6nBBlfx9V/u/SM3y7OtR+sWH4WhhDU6W1GHKkC69rFM1UrDjhsxOfmUDzBbhkjoge3pb40WpuzT5ty79FJ9++mksXLjQYX8sIiJyvQ1Hih0e/3K2KdiRVgx1VoOxZWfgfnHWbM6p0rouvWZb5GmsENcFOwkRwQhSKWCyCHmvL1cymK2ZHU0XCsDJ93Qps/Piiy/ixIkTSExMRJ8+fRAU5PgHeM+ePS4ZHBFRT3eusgF55fUI0agQF67FabtgpKax88HOtwcLUW7bLdy+f0xf25TYyRI3BDtyZsd101gqpQIpUSE4U1aPs+X16OVk09CukrbO0LLHTkDo0p+8a6+91sXDICIiiRBN+z3tOVOB6a9sRlJkMNY/cAlKa5u2dOhsZmfLsVLc9cFu+bF9ZqdvvDXYcU9mR6rZcV1mB7BOZZ0pq8fZigaMd+krs0A50HQ62DGZTFAoFLj99tuRmprqjjEREfVo0i9aAKi2ZW9OltThaGENSuya6NV2MrPzye48h8f22zZIxc6F1Y0orzMgJkzT6XE7I70HV9bsAEBqVCiAMrcUKUtLzxnsBIZO/xTVajVeeOEFmExdmysmIqK21dutuLK35XiJvL8U0LnMjsFkaVH/Y/+LPCpUgz6x1hVO//f+LofsUnc1ZXZcu8eU1B/IHZ2fDVyNFVC6FLJOmTIFmzZtcvVYiIgITfsyNffjsVKU2AU7nanZKahqQE2z123eI+3vvz0PKqUCO09XuHQbhmo3rMYC7Ds/uz7YkbJrbCoYGLoUZs+YMQOPPvooDhw4gLFjxyIszLHXw9VXX+2SwRER9UTSaimlArh0cAIKqhpxuKBabiYoqdWbYLEIKDuw7FrqYtyW4b0ikaQLxrnKBpytaECiLrhrb8CO3mSWt15wfbDjvsaCnMYKLF0Kdu655x4AwEsvvdTinEKhgNncegqWiIjaJ2V2kiND8M5t5wMALntpE44V17a4tqbRhBCNqt0MRGEHgh0A6BUVgnOVDcivbMDY9OhOjrwl++xTuAtXYwFNmZ2CqkaYzBaoXbhMvGk1FoOdQNCln6LFYnH6xUCHiKh7pC7J9k0DZ4xIlr9PiQyG2pbNGfXUWlz0140oq2172knK7PS3rbpyFsikRFmzOedctOeUVK8ToVW7vPFfQoQWQSoFzG7otSP12WHNTmBgyEpE5GOkvatCNE2ZkGtHN20b0WA0O2RJSmr0+D6npM3XLKyyBi/ThyXh+4cm4/07Lmj1ul7Rrt1gU16J5eJl5wCgVCrk/jqunsqSMzucxgoIXcopPvXUU22eX7hwYZcGQ0REQH2zvasAoF98035VdXozjBaLw3O2HCvBDWOdtwORMjvJkcFyA8HWpNiCh3MuCh5+OVsp39cdEnTBOF1W77Ak35mtJ0pxpqwevxmX1m6WiTU7gaVLwc7q1asdHhuNRpw6dQpqtRr9+/dnsENE1A31zXYll6yZexHm/nsPHpw2CPM/3u9wbsvxsjaLlaVpnqTItjsNS5kSV01jfbYvHwBw+fAkl7xec1IXaPveRK3ZcKQId763CxYBbDleimW/Pa/N69lUMLB0KdjZu3dvi2PV1dW47bbbcN1113V7UEREPZlUoGzf9A8ARqdF4adHpwCAHOzER2jRaDCjtFaPtYeLnAYVhXaZnbZIwY4rprGKqxux+0wFFArgqma7t7uKFIw0Gp3Xiwoh8OQXh2GxtQ766pcCPD6zAcltBH7c9TywuCxk1el0ePLJJ/HEE0+46iWJiHqk1gqUm7t1QjoA4MUbRyH7wj4AgLs+2I23fzzZ4tozZXUortFDqQDSbCuYnJFqa+qcNDbsjBO2fbb6xIa5ZBl7a4JtmZ22gp3jxbXILa+HRq1EXLi1M3R7NT4G9tkJKC79KVZVVaGqqqr9C4mIyCm5QDnIefJ98dXDsG3BFFw8KB53TOwLqT/g8h9OtLh2zV7rVNJFA+IQGdp2oXCwLZNhtggYzW1PDbVH6mws9cNxh2Db0vC2prE2HLV2jr6wfywGJFhrn9qrSWLNTmDp0jTWa6+95vBYCIGCggK8//77mDFjhksGRkTUUzVIBcptZHZUSoU8DRMdpsGPf74UE//6PcrqDNCbzA7TL98cLAAAXDemV7v3DtY0/XJvMJoR1I3eNVLdj6t3JLcnvU99G5mdbSfKAFgbNP5ytgpAebs1SfI0FvvsBIQuBTsvv/yyw2OlUon4+HhkZ2djwYIFLhkYEVFP1bT0vOP1Ir2iQqBRKWEwW1BcrUdaTNN0lbSfVkaKrt3X0aiUUCgAIaxTQ93peixlT9wZ7EiZncY2Mjt55dYM08DEcJTVWXeNb28aq2npOWt2AkGXgp1Tp065ehxERGQj1+xoOv6/aIVCgQSdFmcrGlBc0+gQ7DTI02Lt/+JWKBQICVKh3mBGo6G701jWgCI1xp3BTts1O0IIhwxTagdXmzU1FWRmJxB06ad4++23o6ampsXxuro63H777d0eFBFRT1Znm8bqTGYHAJJsRcCFVU09Z4QQ8l5bHQl2ALsAwtS9IuWmIKPtoujukMYqZWKas07rWaBQWLffkJomnmtn81BpWowFyoGhSz/Fd999Fw0NLaPihoYGvPfee90eFBFRTyYtPe9MZgcAEm3Lyu23TtCbLPKS644GT8EdWM7dHqPZggJb1+ZebixQlpeeOwnMpKm0hAgtNGql3dL6treX4NLzwNKpv0nV1dUQQkAIgZqaGgQHNy0lNJvN+Prrr5GQkODyQRIR9STFtm7ACTptp56XGGH9f3KRXbBjH7AEdzSzYwuKGrqx/PxfW07BaBaIDdPIGSd30LYzjdW8SDo61Lr0vMFoblHIbY9NBQNLp4KdqKgoKBQKKBQKDBo0qMV5hUKBJ5980mWDIyLqaYQQ8tYOnQ0SkiKtwdE/Np/E9ef1wpAknTyFFaRSdHhllbT8vK2i37Y0GMx4feNxAMCjM4a4fANQe1IWytnSc7lI2tZfyH6FW53eebBj4GqsgNKpYOf777+HEAJTpkzB//73P8TExMjnNBoN0tPTkZLini6ZREQ9QUW9Uf5F2+nMjl1w9PK6X/HWrePkrSc6mtUBmqa7ujqNteFoEWr1JqRGh7S5X5crdDazo1YpERKkQoPRjNpGE2LCNC2eY7EIuUBZ042l9+Q7OhXsXHLJJQCsq7F69+4NhcJ90ToRUU8k1bnEhWs6XS+S2S9W/l5aCdUg77PV8deSl3N3MdiR9sO6elSK239PNNUXtZ7ZOVlq7eLc2251Wniw2hrs2GqjmjPYNVPUdiJIJN/VpZA1PT0dW7Zswe9+9ztceOGFOHfuHADg/fffx5YtW1w6QCKinkTawyqpC7uEJ+iC8fm8iwA09dZp7ORKLPtruxLsmC1CbuJ3xYjkTj+/s4Lb2Qj010LryuHBSRHysQit9d/5zoId+5VdzOwEhi79FP/3v/9h+vTpCAkJwZ49e6DXW/9SVVVV4bnnnnPpAImIehJ5d3Jd11YwJdiKlEtrDTBbmpadd2YaS8pmdKVA+URJLWr1JoRqVBia3H4Tw+6SCohb66BcVW+UP89BieHy8TA52DG2+pr1RmsQpFYquPQ8QHTpp/jMM8/gzTffxD//+U8EBTV117zooouwZ88elw2OiKinySu3Tj+1tzu5M3HhGigU1gxLeZ1BrtnpTM+e7hQo78urBAAM7xXp1sJkSVtNBX8ttmZ1ekWFIMKuE3S4LdipaWw9s1Pfhak/8m1dCnZycnJw8cUXtzgeGRmJysrK7o6JiKhHsFgELFITHAAbjhThzU3WjTy7Mo0FWAtwY21Ft8U1jXIQ0Jlf3CGartfs7LcFO2PSojr93K5wNo2VU1iDG9/cBsAxqwNYa3YA59NYTXVOXdpkgHxQl4KdpKQkHD9+vMXxLVu2oF+/ft0eFBFRoDOYLLj81c246R/bIIQ14Fl7qEg+P3lwfJdfO942lVVco+/UVhESKbPT0IVgZ8epcgDAKA8FO1onDRDXH2n6LM/vG+NwTq7ZcZLZkZo6MrMTOLoU7Nx555247777sGPHDigUCuTn5+Pf//43HnzwQdx9992uHiMRUcDZm1uBX4tqsfN0hRxUlNiKip+/fgSGpUR2+bUTIqxL1ktq9N1aeu5sCwZnTpfW4XhxLdRKBS7qH9ep53ZV09YWjmMtsTVmHJsejTsm9nU4J2V26pxkduqlbFgbu86Tf+lSju7RRx+FxWLB1KlTUV9fj4svvhharRYPP/ww/vCHP7h6jEREAedMWdPeTBX1RoRq1CiusRbTdra/TnP2wY6kU5mdLhYoS9mUC/rGIDK067uld4a0TN5sETCaLXLjROm9XzkyucUSfrlmp71prCBOYwWKLmV2FAoFHnvsMZSXl+PgwYPYvn07SkpKEBkZib59+7b/AkREPdzhgmr5+8p6A4CmX9Dx4d3bXkEKloqqu1az095+U85sPlYKAJgyxHPbBtkHMvZ1O/JnGdEycAxrZxqrK0Xd5Ns6Fezo9XosWLAA48aNw0UXXYSvv/4aGRkZOHToEAYPHoxXX30VDzzwgLvGSkTk97adKMMr63/FntwK+VhlvREWi0BprTXoae0XdGckRzZtdillKYI7VaDcuT47eeX1mLPiZ2z+tQQAMMGuuaG72e9dZT9eaUowPrzlZxnRToFyvYE1O4GmUzm6hQsX4q233kJWVha2bt2KG2+8EXPmzMH27dvx4osv4sYbb4RKxT8cRESt+eVsJbL/9bNDh17AGuzsPF0Os21lVmx4yy0MOkPaGuFcZYOc5elagXLHanb+tjYH3+dYA51QjQpD7Br4uZvS1gvHYLI4BjttZHbC22kqWM/VWAGnUz/JVatW4b333sPVV1+NgwcPYuTIkTCZTNi/fz+3jiAiakNprR53vb+7RaADAF8fKMBXBwoAADFhmg5v2OlMr2gps9OAobbAo1MdlG0ZjUPnqlBvMLX7S7+8ziB/L4R1+bsnBduCHWkaq95gkgOZtoId9tnpOTr1J/Ls2bMYO3YsAGD48OHQarV44IEHGOgQEbXj5XW/Ir+qEf3iwrD4qgzMuagPrhiRBAByoAM0/SLujhRbZqeqwShP53Rlb6yyOgMeW32w3evtMyR/mjqwM0N1ieabgZbWWIOv4CBlq59nu6uxuPQ84HQq2DGbzdBomtKrarUa4eHhbTyDiIiMZosc0Dx5zTDcdlFfLLpqGNKiQ1tcm1te3+JYZ4Vr1YgMsa6GOlFcC6CT20XYFf2u3nuu3eulrs9/mjKgxTJvT2jauNSa2Smpta5qi4/QtvqP8XansYycxgo0nfpJCiFw2223Qau1pgUbGxtx1113ISwszOG6Tz/91HUjJCLyc1uOl6Ky3oi4cI3DzuRRoS1rczJctJ9USlQIqhqMyLdtLNqZlUXpsU1BWN+4sDautC7TljYdvX1iX6/sJaULDgLQgOpG615XxdXOi5OBpoxNvZOl9V3ZKZ58W6eCnezsbIfHv/vd71w6GCKiQCOEwBvfWzvOzxyR7FDPEtWsF811Y3ph7qUDXHLfXlHBOGK3vD02rOMrvFKjQ/HXWSPwyP8OwCJEm9eeq7RmoiLsskmeFmPbHqPCVjskZcdSW8mcAU0ZG2nVVXPScS49DxydCnZWrFjhrnEQEQWckho9bnxzK06X1SM4SIn/u6S/w/lou2AnOTIYL9802mX37h8fjvVHigFYg4FxfaI79Xypg3N7y8+lKazUmFCv1W9KGTKpUPqMLdjpE+ss2LEGMUazYyNCCQuUAw/3ricicpPtJ8tw2tYp+bGZGXLhsCQypGkaK2tookvvfdtFfeTvJw+K7/QKr+Z1MM6cKasDAKRFh7R5nTvF2ILGCltzRmlMvWNbn4Kzz9i0NpXFpeeBh8EOEZGbSL98Lx4Uj1snpLc439su8zD/skEuvXdyZAhevmkURqVF4b6szq+QkoqU28vsnCq1Bhb94r23WCVamsaqt9bsnC5tO7OjUSmhUlqzUK1ticHMTuBh2EpE5CbStEqvqNazHr2iQvDx/2UiUaeVf2G70nVjUnHdmNQuPVdavaU3WSCEcDpFdVIKdtopZHYn+5odvcmM/Crr1Fq6k8yOQqFAqEaFmkZTq3U7DeygHHAY7BARuUmlLdMQ3cammBf0jfHUcDpFmsYCrAGPs6XrJ0uswU7feO8FO/Y1O2crGiAEEKZRIa6NTtRNwU7LzE4dp7ECjlensZYsWYLzzz8fERERSEhIwLXXXoucnByHaxobGzF37lzExsYiPDwcs2bNQlFRkcM1ubm5mDlzJkJDQ5GQkICHH34YJlPrVfZEga5Ob8LPp8oh2llFQ+4nTWPFuCFr4272wY2zqaxGY1MWxauZnVBpGsuAXwtrAFiDr7YKpptWZLV8b1x6Hni8Guxs2rQJc+fOxfbt27Fu3ToYjUZMmzYNdXV18jUPPPAAvvjiC6xatQqbNm1Cfn4+rr/+evm82WzGzJkzYTAYsHXrVrz77rtYuXIlFi5c6I23RORxFXUGNBjM+Ol4KUpr9fjtP7fjN29tw5p97TeDI/eSprFa66fj64Ls6lqcFSmfLquDEIAuWO3VgC46TCpQNuLAuSoAwIhekW0+R9o+o/k0ltkiUGc7FuaCbtbkG7z6k/z2228dHq9cuRIJCQnYvXs3Lr74YlRVVeGdd97Bhx9+iClTpgCwLn8fOnQotm/fjgkTJmDt2rU4fPgw1q9fj8TERIwePRpPP/00HnnkESxevNih4zNRoDmcX41Zy7eioZV/eT/1xWFMHZpoa7hG3SWEgBDWjSc7qiPTWL4sWK1EncGMRqMZJrMFVQ1GxNo16pP6+AxICPfqtkH2NTu/nJWCnag2nyNlbZoXKFc3GCElRZv3QSL/5VOrsaqqrH9IY2Ksc9i7d++G0WhEVlaWfM2QIUPQu3dvbNu2DQCwbds2jBgxAomJTcs2p0+fjurqahw6dKjV++j1elRXVzt8Efmjv6w+0GqgA1j/lTv+2Q2osv3Cpa4zmi24871dyHx+g9wtuCOkaSx3FB97gjSV1Wgy44XvcnD+s+ux9UQphBB4+8eTePDj/QCAsemd6+HjatG2zJnJIrDleCmA9jM7obasTV2zYKfc9jOL0Kq7vSEr+Q6f+UlaLBbcf//9uOiiizB8+HAAQGFhITQaDaKiohyuTUxMRGFhoXyNfaAjnZfOtWbJkiWIjIyUv9LS0lz8bojcr7CqEfvyKh2OPTx9MPYvnIbnrhsBAGgwmnGmvK6VZ1NnvLr+GNYfKUZRtR4bbY369udVYtLSjXj7x5NOnyd19I32w2kswC7YMVrw1uaTsAjgvo/2YW9eJZ756ggstgzI+X28W2QdHKRymEbTqJQYlNT2UvjQICmz4ziNVWkLdqLCmNUJJD4zITl37lwcPHgQW7Zscfu9FixYgPnz58uPq6urGfCQ35H2AbJ39yX9oVQq8NvxvfH2jydxsrSu3aZw1DYhBD7ZfVZ+vPVEKfrGh+HGN63Z5ee+PoI/TOrn8JwfcopxvLhWzhr46zSWVm4s2JT9KKnRY9WuPIfrvB3sAMDfbxmDbSfLUFqrx9j0GIfNTFvjbH+sijpp6tE/A1RqnU8EO/PmzcOXX36JzZs3IzW1qSdEUlISDAYDKisrHbI7RUVFSEpKkq/5+eefHV5PWq0lXdOcVquVNzMl8lfSLyCVUoFhKTrMOi/VoZ5EG9SxpnDUtrzyBhRWN8qP1+zLx5p9+fJji7AWtUrFvGW1evzh3V0wWZpWw/lr3VSwuvUi3v/83BTsTBwQ5xPTdBcOiMOFA+I6fH2Is2Cn3n+Lysk5r05jCSEwb948rF69Ghs3bkTfvn0dzo8dOxZBQUHYsGGDfCwnJwe5ubnIzMwEAGRmZuLAgQMoLi6Wr1m3bh10Oh0yMjI880aIvEDK2KTHhuLzeRORfWEfh/PBrfyrnDpvx6kyAMDwXjp5BQ8AXDkyWf4+z7YXEwBsPFrsEOgAnStq9iXSn6GzFQ0tzo1Oi8KBxdOwcs75nh6WS8gFys3+fvh7UTm1zquZnblz5+LDDz/EZ599hoiICLnGJjIyEiEhIYiMjMQdd9yB+fPnIyYmBjqdDvfeey8yMzMxYcIEAMC0adOQkZGBW2+9FUuXLkVhYSEef/xxzJ07l9kbCmjS/6SDnaTrpePOCpipY3aeLgcATBoYjz9PH4Ivf8lHn7gw3HVxf5wsqcPhgmocL65FH1ufmfVHrJnlaRmJ2H6yDBf273i2wddINTvS9gtKBZAWE4qyWgOeu24EIvw0YwU09dmp0ztmreSicmZ2AopXg53ly5cDACZPnuxwfMWKFbjtttsAAC+//DKUSiVmzZoFvV6P6dOn44033pCvValU+PLLL3H33XcjMzMTYWFhyM7OxlNPPeWpt0HkFVLGxr7TrT0pTa9nzU63HMq3rtYclRqFiwfF4+JB8fK5AQnh1mCnpBZZSESj0YzNv1pXA/1p6kC8evMYpz8ffyAFO9LGmiNTo7DqrkzUNpp8YuqqO5wtPa+oZ81OIPJqsNORDq/BwcFYtmwZli1b5vSa9PR0fP31164cGpHPawp2nGR2pGksEzM7XWU0W3CsqBYAkJGsa3F+YIJ1xc9+26q4bSfK0GA0IzkyGMNSdF7tPeMK0p+hU7ZgJ0kXjCCV0u8DHcB5gXKl3C7Af7NW1JL//pODqIeTMjZOgx116/9ypY47VVoHg9mCcK0aqdEtN/OcMjQBALDucBGKqxuxzjaFNXVogt8HOkDTn6EzZdZprKTIYG8Ox6VCpO0ijCxQ7gkY7BD5KSlj42yaRGvXI4W6RuoQPDgpotUi42EpkTi/TzRMFoGX1x/DF/utq7Quy2h9Jai/kf4MmW0F18kBFOyESZkdffM+OyxQDkQMdoj8VGM7Bcohdt1vqWuO2jaVHJIU4fSaO209dv7zcy5qGk0YmqzDpE4sgfZlzQPpfvFtN+rzJ1JNW4sOyn7eCJJax2CHyE9JGRttezU7XI3VZdKS8r5t7Oh9WUaivF2CWqnAEzOH+u1S8+aaT5EOSAicYCciuOVqLCGEnNnhvliBxSeaChJR5zW0sxormE0Fu62wytpMMDmyZb2ORKFQ4I3Z5+GL/fmYPDghoAIC+6yhRqVEWit1S/5K2tHcPtipN5hhMFv/EcHMTmBhsEPkp6QgJsRJZieENTvdViAFO1Ft16ok6oJbbBkRCOwD6T5xoVAH0MaYYbYC5Vq7YEcqTtaolPJqLQoMgfMnl6iHaWxvNRansbrFbBEoqpYyO4FTmNsZ9lM5/eICJ2MFAOG2zI7eZIHJls2xn8IKhNV01ITBDpGf0rczjSXV8rCDcteU1uphsggoFUB8eM/sxn7N6F64YWwqlArrcvpAIk1jAUCd3vp3hN2TAxensYj8VNPSc2eZnZ5Xs3PwXBX6xYfJWwF0hzSFlagLDqjpm84IDlLhbzeOwrPXDW93F3F/o1EroVEpYTBbUGswITI0SO6ezOLkwMNgh8hPydNY7S097wE1OxaLwD9/PIkl3xxFr6gQ3D25P2adlyovL+6Kgkrr5peB1EivqwIt0JGEaVUw1FvkImWpe3JMAHSIJkcMdoj8lJSx0TpdjdUzanbe/vEkXt94HFUN1n+Vn6tswONrDiKnsAZPXzu8y697stS6RUJKGyuxyL+FadWoqDfKRcoVdVJmh8FOoOmZuVmiANDQ7t5YgT+NdSi/Cs98dUQOdEamRiKzXywA4P3tZ9B3wVc4ZQtaOuJ0aR0+3pmH9YeL8OYPJwAA4/pEu37g5BPCmy0/b6rZ4TRWoGFmh8hPtbsaS+0b01ibfy3BY2sO4G83jMJ4WyAiOVZUg/gIbZf/Jf3xzjwAQGa/WPzj92MREWz9JXXzP7Zh+8lyCAGs2XsOD1w2qN3Xqqo3YsarPzoUdI/pHYVbJ6R3aWzk+5r32mGBcuBiZofIT8mrsdSt/zUO0fjGrufzPtyDvPIG3PSP7Th4rko+vv5wEaa9shm//ecOWGx7L3WGxSLwmW0vqrsm95cDHQB4/ZbzMKJXJABg64nSDr3etpOlDoFOqEaFl38zuscWJ/cEUrBTK6/GYoFyoOLfYiI/JTcVdFKEq1X7xjRWo6kps3Tl61vw2b5zKKnR45H//QIhgMMF1fJu4Z1xsrQOlfVGBAcpcVF/x4xRfIQWy357HgBgb24l6g2m1l7CwdYTZQCAG8amYv5lg/Du7RegTxvbRJD/i2iW2ZG2B4mL6JmtBgIZp7GI/NATaw4i37Y0uv2aHQuEEG02Sfv2YAGCVEpMHZro8rFGhQShuEYvP37w4/3oHROKsjoD1EoFTBaBD7afwfRhHd8pXAiBnafLAQDDUyJbzb6kxYSgV1QIzlU2YPeZCkwaGN/ma/503JoByhqaiMuHB8au5dS2MK3170it3oQzZXU4VVoHtVIh73VGgYPBDpGfOVfZgPe3n5EfO116bpfx0ZssToOiXafLcdcHewAAe564zKXLbvUmM0pq9Q7HTBaBk6V10KiUePa64Xj4k19w8FxVuwGZvYc/+QWf7D4LABiZGtXqNQqFAuP6ROPcvgbsOVPpEOzUG0z48VgpPtt3DnV6Myb0i8WJkjoEqRSY0C+ma2+W/I40jfXCdzn45WwlAGtBui6Y01iBhsEOkZ9Zd6jQ4bHTjUDtanmmvbwZt13YB7dP7AsAaDCY8cYPx7HjVLlDHc2W46W4elSK03ubzBaolIoOByXnKhogbOU4H9wxHoMSw/HPH0+iqsGI301Ix6DECDzyv19QUW9EcY0eibq2e9rsOl2O+z7ah3O2HjgAMCot0un1Y9Oj8dm+fOzOrUBFnQGVDUY8+9Vh/JBTApNdndCmX0sAWDsGc9lxzxFu10X5u0PWqdRLBwdWp2iyYrBD5EeKqhvxwY5ch2NaJxkbtUqJSQPj8OOxUuSW1+PZr4/gihHJSIoMxmOrD+DTvedaPGfzryUtgp3KegMKqxvx3NdHsfnXEvSPD8Nz141osbKqNXkV1qBkcGIEJg6MAwA8NjPD4Zp+8eE4XlyLwwXVToOd0lo9nvziML6wFSRLdMFqXNg/zun9z+sdLb+v8c9tkHe0BoC4cC2uG5MCo1ngPz9bP9P/uzjwNvMk50QrdfFXj3Ye7JP/YrBD5EceX3MQx4trERGsxuDECCRHhUAX7Pyv8Ruzz8Oizw/h0z3nYLYI3L5yJxZfPQxr9lkDnXunDMDAxAgEKRW4+997sPnXElgsAkqlApX1Brz94ym8v/2M3McGAE6U1OEP7+7C+gcvaTcTk2sr+EyLcd6Yb2iyDseLa3GkoNrpv6pfWverQ6AzvJcOr948Br2iQpxOzwHAkKQIRGjVqNGb5EAnLlyLf902zmH6694pA1BvMCMtJrTN90OBbWBCOJLZRDIgMdgh8hNCCOw4aV0x9K/bzsf5fdqvLYkIDsJLvxmNyYMT8Kf/7MXhgmr85q1tAIBJA+Pw4LTBAKy1NRFaNYpr9NiTW4HzekfjD+/uwq4zFQ6v1zsmFLoQNQ6eq8ZzXx/BqzePafP+m23TQ0OTdU6vGZaiwxf78/H5vnzcflFfOXipqjeitE6PeR/uxZGCavn6926/ABcParvYWKJWKfHyTaPx6KcHEK5V4S9XDMXotCgkNAvSYsO1aD9PRYHmjol9cby4FqPSorDzdDn+csVQbw+J3ITBDpGfyC2vR3WjCRqVEqOcFOU6c+WIZNQ0GrH8hxM4W9GAyJAgPDpjiHxeq1YhKyMRq/eew9/W5iBcG4RdZyqgViowrFck9udVAgCuGpWMGcOTceXrW/D5/nzcN3Ug+sWHt3rPU6V1WHfYWgdx5UjnUwPXn9cL/9x8EkcLa/DI/37B4KQIfLDtjLzaTDIuPRqr7srscL2QJCsjET8PSYBZCASxZw7ZiQ7T4M1bxwIA7kZ/L4+G3Il/84n8xC9nrYXEQ5MjoHHSSNAZpVKB2ePT8fm8iXh85lB8MW8ihqU4FvbOHJEMANh+shzrbX1vFl89DP+w/TIArCufhveKxNQhCRACeH3j8Rb3slgEnvv6CC792w8ArPU6g5MinI4tISIYr9w8GmqlAp/ty8fSb3NaBDoPZA3C29njOh3o2L9/BjpEPRczO0R+Qlo1NbyX89VH7YkJ0+APk1ovwp06NAFPXj0Mp8vqYLYIXDEiGRNsRcg3jUvDseIaXGxbvv2nqQOx4WgxVu89hxvHpToUCX91oAD/2HzSNlYdnrtuRLvjmjQwHi/dNBoPr9oPva0J4e0X9UWYVoXU6BDcdH7vLr9nIiIGO0R+IqeoBgCQkeK8/qU7FAoFsi/s0+q5v94w0uHxqLQo/GZcKj7edRa3r9yJZb89D5EhQRjTOxpv2DbQ/MPEvnj8yozWXq5VV49KwejUKBzMr8L0YUlQKbuWxSEiao7BDpGfyC2zrmzqE+sbWxgsvGoYCqoa8eOxUtzx7i4AwAV9YnCkoBrhWjXmTRnQ6dfsHRuK3rFcEUVErsVJbCI/YLYInLX1rOntI8ujw7VqLLnecYrqZ9sWDs9dP4LN+YjIZzDYIfIDhdWNMJgtCFIpkBLlO31AUqNDcf15vRyOjegV2WYXZiIiT2OwQ+QHzpTVAbAGF75Wy7Lk+hFYdVem/PjSwR3rgUNE5CkMdoj8gFSv4ytTWPa0ahXO7xODSwbFIzo0CL8dn+7tIREROWCBMpEfOGPbdiHdh4t338keB5NFtLl9AxGRNzDYIfIDx2zLzvs76VbsC9QqJdSMc4jIB3Eai8gPHC20BjttdSImIqLWMdgh8nG1epO87HxwIoMdIqLOYrBD5MPyyusxfNF3AID4CC2iw9i7hoiosxjsEPmwz/fny9+nRftOfx0iIn/CYIfIh+05UyF/f2sml3QTEXUFV2MR+SghBPbkWoOd1fdciDG9o708IiIi/8TMDpGPOlVah4p6IzRqJYalRHp7OEREfovBDpGP+vFYKQBgTFoUNGr+VSUi6ir+H5TIR60/UgQAyBqa6OWREBH5NwY7RD5ox8kyObOTlcFgh4ioOxjsEPmYijoDbl+5EwAwNj0afePCvDwiIiL/xmCHyMesP1KEOoMZvaJCsGLO+d4eDhGR32OwQ+RleeX1eParw6ioMwAAvj1YCAC46fw06IKDvDk0IqKAwD47RF427z97sT+vEj+fKsdbt47D5mMlAIDpw5K8PDIiosDAzA6Rl+3Pq7T+92wVln53FEazwAV9YrjDORGRizDYIfKylMhg+ftP95wDANxzaX9vDYeIKOAw2CHyMpNFODx+6pphmDw4wUujISIKPKzZIfIis0WgtFYPAIgN02DZ7PMwoV+sl0dFRBRYGOwQeVF5nQEWASgUwI6/TIVaxWQrEZGr8f+sRF5UXNMIAIgN0zLQISJyE/7flciLimusU1gJEVovj4SIKHAx2CHyopJqa7ATz2CHiMhtGOwQedGx4hoAzOwQEbkTgx0iLymvM+DDHbkAgKlDudSciMhdGOwQeclXBwpQZzBjaLIO0zK4NQQRkbt4NdjZvHkzrrrqKqSkpEChUGDNmjUO54UQWLhwIZKTkxESEoKsrCwcO3bM4Zry8nLMnj0bOp0OUVFRuOOOO1BbW+vBd0HUNUcKqgEAlw6Oh1Kp8PJoiIgCl1eDnbq6OowaNQrLli1r9fzSpUvx2muv4c0338SOHTsQFhaG6dOno7GxUb5m9uzZOHToENatW4cvv/wSmzdvxh//+EdPvQWiLjtqC3aGJOu8PBIiosDm1aaCM2bMwIwZM1o9J4TAK6+8gscffxzXXHMNAOC9995DYmIi1qxZg5tvvhlHjhzBt99+i507d2LcuHEAgNdffx1XXHEF/va3vyElJcVj74WoMywWgV+LrBnIIdzwk4jIrXy2ZufUqVMoLCxEVlaWfCwyMhLjx4/Htm3bAADbtm1DVFSUHOgAQFZWFpRKJXbs2OHxMRN11LnKBtTqTdColOgbF+bt4RARBTSf3S6isLAQAJCYmOhwPDExUT5XWFiIhATHVSxqtRoxMTHyNa3R6/XQ6/Xy4+rqalcNm6hDpCXn/eLDEMTOyUREbtUj/y+7ZMkSREZGyl9paWneHhL1MAVV1rqz1OhQL4+EiCjw+Wywk5RkXYpbVFTkcLyoqEg+l5SUhOLiYofzJpMJ5eXl8jWtWbBgAaqqquSvvLw8F4+eqG1Fts7JiTo2EyQicjefDXb69u2LpKQkbNiwQT5WXV2NHTt2IDMzEwCQmZmJyspK7N69W75m48aNsFgsGD9+vNPX1mq10Ol0Dl9EnlRcbc3sJOqCvTwSIqLA59WandraWhw/flx+fOrUKezbtw8xMTHo3bs37r//fjzzzDMYOHAg+vbtiyeeeAIpKSm49tprAQBDhw7F5ZdfjjvvvBNvvvkmjEYj5s2bh5tvvpkrscinFcrBDjM7RETu5tVgZ9euXbj00kvlx/PnzwcAZGdnY+XKlfjzn/+Muro6/PGPf0RlZSUmTpyIb7/9FsHBTf8a/ve//4158+Zh6tSpUCqVmDVrFl577TWPvxeizmiaxmJmh4jI3RRCCOHtQXhbdXU1IiMjUVVVxSkt8oixT69DWZ0B39w3CUPZVJCIqEs6+vvbZ2t2iAKV3mRGWZ0BADM7RESewGCHyMNOldYBAIJUCkSHBnl5NEREgY/BDpEHGUwW3PvhXgBA//hwKBTcAJSIyN0Y7BB50IFzVThWXIsIrRpLbxjp7eEQEfUIDHaIPGhfXiUA4IK+MRiZGuXVsRAR9RQMdog8aL8t2BmdFuXVcRAR9SQMdog8aP/ZSgDAKAY7REQew2CHyEPK6ww4U1YPABjFKSwiIo9hsEPkIVJWp19cGCK55JyIyGMY7BB5iFSvwyksIiLPYrBD5CHSSqxRqZHeHQgRUQ/DYIfIA4QQTSuxekd7dzBERD0Mgx0iD8grb0BFvREalRJDkyO8PRwioh6FwQ6RB+zNqwAADE3RQatWeXk0REQ9C4MdIg/Yn1cFABjNeh0iIo9jsEPkAb+wmSARkdcw2CHygNxyazPBAQnhXh4JEVHPw2CHyM2MZgtKavUAgOTIEC+Phoio52GwQ+RmxTV6CAEEqRSIDdN4ezhERD0Ogx0iNyusagQAJOqCoVQqvDwaIqKeh8EOkZtJwU5yZLCXR0JE1DMx2CFys4KqBgBAEut1iIi8gsEOkRs1Gs34eFceACBJp/XyaIiIeiYGO0RuIoTAvA/34teiWgDM7BAReYva2wMgCkRV9UZ8tv8c1h8pko+NTmP3ZCIib2CwQ+Riv5ytxDXLfoIQ1sfzLh2A7Av7ID6C01hERN7AYIfIxT7dc04OdG65oDfmXzaIS86JiLyIwQ6RCwkhsO6wderq9VvG4KpRKV4eERERsUCZyIWOFtbgXGUDgoOUyBqa6O3hEBERGOwQudR6W1Zn4oB4hGhUXh4NEREBnMYicgmLRcBkEfjqQAEA4LKMBC+PiIiIJAx2iLqptFaP37/zMw4XVAMAFApgyhBOYRER+QoGO0Td9PCq/XKgo1Yq8PtMLjMnIvIlDHaIukEIgV2nKwAAb906Fpn9Y6ELDvLyqIiIyB6DHaJuqG4woUZvAgBcPJBFyUREvoirsYi6Ia+iHgAQG6ZhoENE5KMY7BB1w7nKBgBAajQ3+SQi8lUMdoi64WyFFOyEenkkRETkDIMdom44V8HMDhGRr2OwQ9RF+/Mq8a+fTgFgsENE5MsY7BB1QZ3ehLs+2C0/HpEa5b3BEBFRm7j0nKgLXlr3KwqqGhETpsH7d1yAYSmR3h4SERE5wcwOUSf9fKoc72yxTl+9eOMoBjpERD6OwQ5RJ73xw3EAwG/GpeLSIdzwk4jI1zHYIeqEL/bn44ecEigUwD2TB3h7OERE1AEMdog66NuDhbj3P3sBAJcNTUSfuDAvj4iIiDqCBcpEHVDTaMSizw8CAK4alYLnrhvu5REREVFHMdghaofJbMGizw+hqFqPPrGheOGGkQgO4j5YRET+gsEOURuWfX8c//zxJCrrjQCAZ64dwUCHiMjPMNghcqKsVo+X1/0Kk0VAF6zG/VmDMHFgnLeHRUREncRgh6gVtXoTHv7kF5gsAn1iQ7Fu/iUIUrGen4jIHzHYoYD0a1EN1h0uQk2jCbvPlKO8zoB+8eEICVKhutGIK0Yk48axqVAoFK0+f96He/BDTgkA4PaJfRnoEBH5MQY75NcsFgGFAlAoFLBYBKoajNiTW4F7/r0HepPF4doTJXXy9z/klEBvNOPWzD4AgMP51Sip1cMiBHadLpcDnatGpeCGsakeez9EROR6DHbIb+hNZpytaMCJ4lp8sCMXJ4prUVzTCJVSgfSYMOSW16PBaJavH5IUgYxkHdJjwzCmdxSOFdfCbLHgSEENVu89h6Xf5eBIYQ2qGoz46peCFvf748X98JcrhnryLRIRkRsw2HGjkho96g0mNBotaDSarV8mCxoMZuhNZtQbzKjTm9BgMCM8WI1wrRoatRIWIZBf2QiFAggJUkHZylRLTJgGKqUCKqUCxTV6GEwWWCwCZiFgtjR91elN6BUdAq1ahZpGI8xCIDZMg4p6I8wWgXCt9b5BaiWUCkClUEChsL6uUgEolQooFQqEalQoq9WjptEEg9mCmkYTSmr0CA5SosFggd5khsksYDRbYBYCfePCMDgxAiaLQHCQChq1dRroZEkt9CYLiqobcbq0DiqlAkIARTWNCAlSYUBCOAYmRCA4SIUGoxk7TpahqsGIsxUNyK9qgBAtP2ejWSCnqEZ+rFEpcd2YXlh89TCEaJpWTl08KB6AdSl5TmENDhdU48MdufL5XlEhiA4LQrhWjcsykpCdme6qPwpERORFDHbcaNbyrcgtr/f2MPzKztMVbZ4P06iQFhOKMb2jcPWoXkiNDkG9wYz9eZXISNFhYGI4FFDIwVVr1ColVt2ViXWHi/BrUQ0ajRZcPCgOkwdznysiokDEYMeNwrRqhGpUCA5SIVitRLBGhWC1CsFBSgQHqRCqUSFMq0ZIkAp1BjNqGo0wmq11JokRwVAqFWg0mtEimSGAwupGKAAYzRbERwQjVKOyZWMUUCsVUCoVUCkBjUqFM2V1UCoViNCqIQBU1BsQE6qBWqVAnd6MGr0JRpMFFiFsX7D+12L93mwRqNWbEB0ahKhQDTRqJUI1KiTqgmEwWRAcpIJWrYRGrUSQypqpySmswYmSWmiDVNCbLDDY6mcSIrSICdMgNkyDfvHhUCisr58cGYxavQnHimpxrLgGZot1DMNTdBiQGIFeUcFIjw1DbJim1aLiwUkRnf7ZXDumV+d/qERE5HcY7LjRN/dN8vYQiIiIeryAWU+7bNky9OnTB8HBwRg/fjx+/vlnbw+JiIiIfEBABDv//e9/MX/+fCxatAh79uzBqFGjMH36dBQXF3t7aERERORlARHsvPTSS7jzzjsxZ84cZGRk4M0330RoaCj+9a9/eXtoRERE5GV+H+wYDAbs3r0bWVlZ8jGlUomsrCxs27at1efo9XpUV1c7fBEREVFg8vtgp7S0FGazGYmJiQ7HExMTUVhY2OpzlixZgsjISPkrLS3NE0MlIiIiL/D7YKcrFixYgKqqKvkrLy/P20MiIiIiN/H7pedxcXFQqVQoKipyOF5UVISkpKRWn6PVaqHVaj0xPCIiIvIyv8/saDQajB07Fhs2bJCPWSwWbNiwAZmZmV4cGREREfkCv8/sAMD8+fORnZ2NcePG4YILLsArr7yCuro6zJkzx9tDIyIiIi8LiGDnpptuQklJCRYuXIjCwkKMHj0a3377bYuiZSIiIup5FEK0to90z1JdXY3IyEhUVVVBp9N5ezhERETUAR39/e33NTtEREREbWGwQ0RERAGNwQ4REREFtIAoUO4uqWyJ20YQERH5D+n3dnvlxwx2ANTU1AAAt40gIiLyQzU1NYiMjHR6nquxYG1CmJ+fj4iICCgUCpe9bnV1NdLS0pCXl8dVXm7Gz9oz+Dl7Bj9nz+Fn7Rnu+pyFEKipqUFKSgqUSueVOczswLpLempqqtteX6fT8S+Rh/Cz9gx+zp7Bz9lz+Fl7hjs+57YyOhIWKBMREVFAY7BDREREAY3BjhtptVosWrSIO6x7AD9rz+Dn7Bn8nD2Hn7VnePtzZoEyERERBTRmdoiIiCigMdghIiKigMZgh4iIiAIagx0iIiIKaAx23GjZsmXo06cPgoODMX78ePz888/eHpJf2bx5M6666iqkpKRAoVBgzZo1DueFEFi4cCGSk5MREhKCrKwsHDt2zOGa8vJyzJ49GzqdDlFRUbjjjjtQW1vrwXfh+5YsWYLzzz8fERERSEhIwLXXXoucnByHaxobGzF37lzExsYiPDwcs2bNQlFRkcM1ubm5mDlzJkJDQ5GQkICHH34YJpPJk2/Fpy1fvhwjR46Um6plZmbim2++kc/zM3aP559/HgqFAvfff798jJ+1ayxevBgKhcLha8iQIfJ5n/qcBbnFRx99JDQajfjXv/4lDh06JO68804RFRUlioqKvD00v/H111+Lxx57THz66acCgFi9erXD+eeff15ERkaKNWvWiP3794urr75a9O3bVzQ0NMjXXH755WLUqFFi+/bt4scffxQDBgwQt9xyi4ffiW+bPn26WLFihTh48KDYt2+fuOKKK0Tv3r1FbW2tfM1dd90l0tLSxIYNG8SuXbvEhAkTxIUXXiifN5lMYvjw4SIrK0vs3btXfP311yIuLk4sWLDAG2/JJ33++efiq6++Er/++qvIyckRf/nLX0RQUJA4ePCgEIKfsTv8/PPPok+fPmLkyJHivvvuk4/zs3aNRYsWiWHDhomCggL5q6SkRD7vS58zgx03ueCCC8TcuXPlx2azWaSkpIglS5Z4cVT+q3mwY7FYRFJSknjhhRfkY5WVlUKr1Yr//Oc/QgghDh8+LACInTt3ytd88803QqFQiHPnznls7P6muLhYABCbNm0SQlg/16CgILFq1Sr5miNHjggAYtu2bUIIa2CqVCpFYWGhfM3y5cuFTqcTer3es2/Aj0RHR4u3336bn7Eb1NTUiIEDB4p169aJSy65RA52+Fm7zqJFi8SoUaNaPedrnzOnsdzAYDBg9+7dyMrKko8plUpkZWVh27ZtXhxZ4Dh16hQKCwsdPuPIyEiMHz9e/oy3bduGqKgojBs3Tr4mKysLSqUSO3bs8PiY/UVVVRUAICYmBgCwe/duGI1Gh896yJAh6N27t8NnPWLECCQmJsrXTJ8+HdXV1Th06JAHR+8fzGYzPvroI9TV1SEzM5OfsRvMnTsXM2fOdPhMAf55drVjx44hJSUF/fr1w+zZs5GbmwvA9z5nbgTqBqWlpTCbzQ4/QABITEzE0aNHvTSqwFJYWAgArX7G0rnCwkIkJCQ4nFer1YiJiZGvIUcWiwX3338/LrroIgwfPhyA9XPUaDSIiopyuLb5Z93az0I6R1YHDhxAZmYmGhsbER4ejtWrVyMjIwP79u3jZ+xCH330Efbs2YOdO3e2OMc/z64zfvx4rFy5EoMHD0ZBQQGefPJJTJo0CQcPHvS5z5nBDhHJ5s6di4MHD2LLli3eHkpAGjx4MPbt24eqqip88sknyM7OxqZNm7w9rICSl5eH++67D+vWrUNwcLC3hxPQZsyYIX8/cuRIjB8/Hunp6fj4448REhLixZG1xGksN4iLi4NKpWpRdV5UVISkpCQvjSqwSJ9jW59xUlISiouLHc6bTCaUl5fz59CKefPm4csvv8T333+P1NRU+XhSUhIMBgMqKysdrm/+Wbf2s5DOkZVGo8GAAQMwduxYLFmyBKNGjcKrr77Kz9iFdu/ejeLiYpx33nlQq9VQq9XYtGkTXnvtNajVaiQmJvKzdpOoqCgMGjQIx48f97k/0wx23ECj0WDs2LHYsGGDfMxisWDDhg3IzMz04sgCR9++fZGUlOTwGVdXV2PHjh3yZ5yZmYnKykrs3r1bvmbjxo2wWCwYP368x8fsq4QQmDdvHlavXo2NGzeib9++DufHjh2LoKAgh886JycHubm5Dp/1gQMHHILLdevWQafTISMjwzNvxA9ZLBbo9Xp+xi40depUHDhwAPv27ZO/xo0bh9mzZ8vf87N2j9raWpw4cQLJycm+92fapeXOJPvoo4+EVqsVK1euFIcPHxZ//OMfRVRUlEPVObWtpqZG7N27V+zdu1cAEC+99JLYu3evOHPmjBDCuvQ8KipKfPbZZ+KXX34R11xzTatLz8eMGSN27NghtmzZIgYOHMil583cfffdIjIyUvzwww8OS0jr6+vla+666y7Ru3dvsXHjRrFr1y6RmZkpMjMz5fPSEtJp06aJffv2iW+//VbEx8dzqa6dRx99VGzatEmcOnVK/PLLL+LRRx8VCoVCrF27VgjBz9id7FdjCcHP2lUefPBB8cMPP4hTp06Jn376SWRlZYm4uDhRXFwshPCtz5nBjhu9/vrronfv3kKj0YgLLrhAbN++3dtD8ivff/+9ANDiKzs7WwhhXX7+xBNPiMTERKHVasXUqVNFTk6Ow2uUlZWJW265RYSHhwudTifmzJkjampqvPBufFdrnzEAsWLFCvmahoYGcc8994jo6GgRGhoqrrvuOlFQUODwOqdPnxYzZswQISEhIi4uTjz44IPCaDR6+N34rttvv12kp6cLjUYj4uPjxdSpU+VARwh+xu7UPNjhZ+0aN910k0hOThYajUb06tVL3HTTTeL48ePyeV/6nBVCCOHaXBERERGR72DNDhEREQU0BjtEREQU0BjsEBERUUBjsENEREQBjcEOERERBTQGO0RERBTQGOwQERFRQGOwQ0R+4/Tp01AoFNi3b5/b7nHbbbfh2muvddvrE5HnMdghIo+57bbboFAoWnxdfvnlHXp+WloaCgoKMHz4cDePlIgCidrbAyCinuXyyy/HihUrHI5ptdoOPVelUnHXaSLqNGZ2iMijtFotkpKSHL6io6MBAAqFAsuXL8eMGTMQEhKCfv364ZNPPpGf23waq6KiArNnz0Z8fDxCQkIwcOBAh0DqwIEDmDJlCkJCQhAbG4s//vGPqK2tlc+bzWbMnz8fUVFRiI2NxZ///Gc030HHYrFgyZIl6Nu3L0JCQjBq1CiHMbU3BiLyPgY7RORTnnjiCcyaNQv79+/H7NmzcfPNN+PIkSNOrz18+DC++eYbHDlyBMuXL0dcXBwAoK6uDtOnT0d0dDR27tyJVatWYf369Zg3b578/BdffBErV67Ev/71L2zZsgXl5eVYvXq1wz2WLFmC9957D2+++SYOHTqEBx54AL/73e+wadOmdsdARD7C5VuLEhE5kZ2dLVQqlQgLC3P4evbZZ4UQ1h3Y77rrLofnjB8/Xtx9991CCCFOnTolAIi9e/cKIYS46qqrxJw5c1q91z/+8Q8RHR0tamtr5WNfffWVUCqVorCwUAghRHJysli6dKl83mg0itTUVHHNNdcIIYRobGwUoaGhYuvWrQ6vfccdd4hbbrml3TEQkW9gzQ4RedSll16K5cuXOxyLiYmRv8/MzHQ4l5mZ6XT11d13341Zs2Zhz549mDZtGq699lpceOGFAIAjR45g1KhRCAsLk6+/6KKLYLFYkJOTg+DgYBQUFGD8+PHyebVajXHjxslTWcePH0d9fT0uu+wyh/saDAaMGTOm3TEQkW9gsENEHhUWFoYBAwa45LVmzJiBM2fO4Ouvv8a6deswdepUzJ07F3/7299c8vpSfc9XX32FXr16OZyTiqrdPQYi6j7W7BCRT9m+fXuLx0OHDnV6fXx8PLKzs/HBBx/glVdewT/+8Q8AwNChQ7F//37U1dXJ1/70009QKpUYPHgwIiMjkZycjB07dsjnTSYTdu/eLT/OyMiAVqtFbm4uBgwY4PCVlpbW7hiIyDcws0NEHqXX61FYWOhwTK1Wy0W9q1atwrhx4zBx4kT8+9//xs8//4x33nmn1ddauHAhxo4di2HDhkGv1+PLL7+UA6PZs2dj0aJFyM7OxuLFi1FSUoJ7770Xt956KxITEwEA9913H55//nkMHDgQQ4YMwUsvvYTKykr59SMiIvDQQw/hgQcegMViwcSJE1FVVYWffvoJOp0O2dnZbY6BiHwDgx0i8qhvv/0WycnJDscGDx6Mo0ePAgCefPJJfPTRR7jnnnuQnJyM//znP8jIyGj1tTQaDRYsWIDTp08jJCQEkyZNwkcffQQACA0NxXfffYf77rsP559/PkJDQzFr1iy89NJL8vMffPBBFBQUIDs7G0qlErfffjuuu+46VFVVydc8/fTTiI+Px5IlS3Dy5ElERUXhvPPOw1/+8pd2x0BEvkEhRLOmEkREXqJQKLB69Wpu10BELsWaHSIiIgpoDHaIiIgooLFmh4h8BmfVicgdmNkhIiKigMZgh4iIiAIagx0iIiIKaAx2iIiIKKAx2CEiIqKAxmCHiIiIAhqDHSIiIgpoDHaIiIgooDHYISIiooD2/46vqJ3piVEYAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mv_return = rl_utils.moving_average(return_list, 9)\n",
    "plt.plot(epsilon_list, mv_return)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title(f'DQN on {env_name}')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "adb870fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConvolutionalQnet(nn.Module):\n",
    "    ''' 加入卷积层的Q网络 '''\n",
    "    def __init__(self, action_dim, in_channels=4):\n",
    "        super().__init__()\n",
    "        self.conv1 = nn.Conv2d(in_channels, 32, kernel_size=8, stride=4)\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)\n",
    "        self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)\n",
    "        self.fc4 = nn.Linear(7*7*64, 512)\n",
    "        self.head = nn.Linear(512, action_dim)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        x = x / 255\n",
    "        x = F.relu(self.conv1(x))\n",
    "        x = F.relu(self.conv2(x))\n",
    "        x = F.relu(self.conv3(x))\n",
    "        x = F.relu(self.fc4(4))\n",
    "        return self.head(x)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
